0:\n self.ssp.params['logzsol'] = zmet\n else:\n self.ssp.params['zmet'] = zmet\n w, spec = self.ssp.get_spectrum(tage=tage, peraa=True)\n mass = self.ssp.stellar_mass\n else:\n # do it by hand. Faster but dangerous\n spec, mass, lbol = self.ssp.ztinterp(zmet, tage, peraa=True)\n self.basis_spec[i, :] = spec\n self.basis_mass[i] = mass\n i += 1\n self.basis_dirty = False","def test_custom_wsr(self):\n def _wsr_gen(num_bits):\n nonlocal gen_wsr\n gen_wsr = [1]*num_bits\n return gen_wsr\n\n gen_wsr = None\n generator = Generator(backend=FakeValencia(), wsr_generator=_wsr_gen)\n job = generator.sample(num_raw_bits=100)\n self.assertEqual(job.initial_wsr, gen_wsr)","def one_basis(self):\n # FIXME: this method should be conditionaly defined,\n # so that B.one_basis returns NotImplemented if not\n # all modules provide one_basis\n if all(hasattr(module, \"one_basis\") for module in self._sets):\n return tuple(module.one_basis() for module in self._sets)\n else:\n raise NotImplementedError","def iterWeights(self):\r\n\t\tyield None","def probed_basis(self):\n return self._pre_kernel * self.number_of_basis","def getWaveform(self, ch=\"CH1\", samples=2500):\n\t\tself.isReady()\n\t\tcounter = 1\n\t\twhile True:\n\t\t\ttry:\t\t\n\t\t\t\twaveform = self.osc.get_waveform(source = ch, start = 1, stop = samples)\n\t\t\t\tbreak\n\t\t\texcept:\n\t\t\t\tprint(\"Retry: \" + str(counter))\n\t\t\t\tcounter += 1\n\t\ty_array = []\n\t\tfor x,y in waveform:\n\t\t\ty_array.append(y)\n\t\treturn y_array","def get_weights(self):\n return self.w","def get_weights(self):\n return self.w"],"string":"[\n \"def generate_all_samples(self):\\n\\n n_samples, n_dimensions, V = self.n_samples, self.n_dimensions, self.V\\n sample_all = np.zeros([n_samples, n_dimensions])\\n\\n X = int(0)\\n for j in range(1, n_samples):\\n X ^= V[self.index_of_least_significant_zero_bit(j - 1)]\\n sample_all[j][:] = [float(x / math.pow(2, self.scale)) for x in X]\\n return sample_all\",\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 basis(self):\\n\\n # lazy evaluation, compute the basis at the first request and store\\n # it until the triangular mesh or the discretization method is changed\\n if self._basis is None or self._frequencies is None:\\n if self.mode == 'fem':\\n self._massmatrix = (self.triangsamples\\n .massmatrix(mode='normal'))\\n stiffmatrix = self.triangsamples.stiffnessmatrix()\\n self._frequencies, self._basis = linalg.eigh(-stiffmatrix,\\n self._massmatrix)\\n # self._basis =\\n else: # 'unit' and 'inv_euclidean' discretization\\n laplacianmatrix = (self.triangsamples\\n .laplacianmatrix(mode=self.mode))\\n self._frequencies, self._basis = linalg.eigh(laplacianmatrix)\\n\\n # make a row vector of natural frequencies\\n # print(self._frequencies)\\n # self._frequencies = self._frequencies.transpose\\n # print(self._frequencies.shape)\\n # return the SPHARA basis\\n return self._basis, self._frequencies\",\n \"def weights(self):\\n return [x.numpy() for x in self.core.w]\",\n \"def getBarySamples(self):\\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c3Fields = np.zeros([self.nSample, self.nCell_cfd])\\n\\n for isamp in np.arange(self.nSample):\\n TauNew = self.TauSample[isamp, :, :]\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(TauNew)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Fields[isamp, :] = C[:, 0]\\n self.c2Fields[isamp, :] = C[:, 1]\\n self.c3Fields[isamp, :] = C[:, 2]\\n \\n \\n self.XC1Fields[isamp, :] = X[:, 0]\\n self.XC2Fields[isamp, :] = X[:, 1]\\n \\n # Get base C1 and C2 field\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(self.Taubar)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Field_base = C[:, 0]\\n self.c2Field_base = C[:, 1]\\n self.c3Field_base = C[:, 2]\\n\\n self.XC1Field_base = X[:, 0]\\n self.XC2Field_base = X[:, 1] \\n\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_s', self.XC1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_s', self.XC2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_base', self.XC1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_base', self.XC2Field_base)\\n\\n np.savetxt(self.resultDir+'RComponent_samples/c1_s', self.c1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_s', self.c2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c3_s', self.c3Fields) \\n np.savetxt(self.resultDir+'RComponent_samples/c1_base', self.c1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_base', self.c2Field_base) \\n np.savetxt(self.resultDir+'RComponent_samples/c3_base', self.c3Field_base)\",\n \"def get_random_wilson_coeffs(self):\\n if self.fit_wc_priors is None:\\n return None\\n all_random = self.fit_wc_priors.get_random_all()\\n return np.asarray([all_random[p] for p in self.fit_wc_names])\",\n \"def basis_vectors(self):\\n return self._basis_vectors\",\n \"def _compute_samples(self, samples):\\n return samples\",\n \"def wave_samples(self):\\n return self._quantized_subsamples\",\n \"def _get_empirical_ch_weights_Python(self, num_input_samples, num_external_samples, seed, list_input_samples=None):\\n assert 1 <= num_input_samples <= 2 ** sum(d.val.width for d in self.input_diff)\\n if self.external_diffs:\\n assert 1 <= num_external_samples <= 2 ** sum(d.val.width for d in self.external_diffs)\\n else:\\n assert num_external_samples == 0\\n\\n PRNG = random.Random()\\n PRNG.seed(seed)\\n\\n def get_random_bv(width):\\n return core.Constant(PRNG.randrange(2 ** width), width)\\n\\n aux_empirical_weights = []\\n\\n with context.Simplification(False), context.Cache(False):\\n input_widths = [d.val.width for d in self.input_diff]\\n if list_input_samples is not None:\\n assert len(list_input_samples) == num_input_samples\\n def get_next_input_pair():\\n for pt in list_input_samples:\\n assert len(self.input_diff) == len(pt)\\n other_pt = []\\n for aux_i, diff in enumerate(self.input_diff):\\n pt[aux_i] = core.Constant(pt[aux_i], diff.val.width)\\n other_pt.append(diff.get_pair_element(pt[aux_i]))\\n yield pt, other_pt\\n elif num_input_samples == 2 ** sum(input_widths):\\n # input_samples == whole input space\\n def get_next_input_pair():\\n for input_sample in itertools.product(*[range(2**w) for w in input_widths]):\\n pt = [core.Constant(p_i, w) for p_i, w in zip(input_sample, input_widths)]\\n other_pt = [diff.get_pair_element(pt[i]) for i, diff in enumerate(self.input_diff)]\\n yield pt, other_pt\\n else:\\n def get_next_input_pair():\\n for _ in range(num_input_samples):\\n pt = []\\n other_pt = []\\n for diff in self.input_diff:\\n random_bv = get_random_bv(diff.val.width)\\n pt.append(random_bv)\\n other_pt.append(diff.get_pair_element(random_bv))\\n yield pt, other_pt\\n\\n found_external_vars = len(self.external_diffs) > 0\\n if found_external_vars:\\n external_widths = [d.val.width for d in self.external_diffs]\\n if num_external_samples == 2 ** sum(external_widths):\\n # external_samples == whole external space\\n external_space = itertools.product(*[range(2**w) for w in external_widths])\\n else:\\n external_space = range(num_external_samples) # num_external_samples > 0\\n\\n def get_next_ssa_pair_external_fixed():\\n for external_sample in external_space:\\n ssa = self.ch_model.ssa.copy()\\n v2c = collections.OrderedDict()\\n if isinstance(external_sample, int):\\n for v in ssa.external_vars:\\n v2c[v] = get_random_bv(v.width)\\n else:\\n for i_v, v in enumerate(ssa.external_vars):\\n v2c[v] = core.Constant(external_sample[i_v], external_widths[i_v])\\n for outvar in ssa.assignments:\\n ssa.assignments[outvar] = ssa.assignments[outvar].xreplace(v2c)\\n ssa.external_vars = []\\n if all(d.val == 0 for d in self.external_diffs) and \\\\\\n self.ch_model.diff_type == difference.XorDiff:\\n other_ssa = ssa\\n else:\\n # RXDiff 0-difference does not mean ssa == other_ssa\\n other_ssa = self.ch_model.ssa.copy()\\n other_v2c = collections.OrderedDict()\\n for i, (v, c) in enumerate(v2c.items()):\\n other_v2c[v] = self.external_diffs[i].get_pair_element(v2c[v])\\n for outvar in other_ssa.assignments:\\n other_ssa.assignments[outvar] = other_ssa.assignments[outvar].xreplace(other_v2c)\\n other_ssa.external_vars = []\\n # print(\\\"# new external samples\\\")\\n # print(\\\"v2c:\\\", v2c)\\n # print(\\\"other_v2c:\\\", other_v2c) # might throw error\\n # print(\\\"external_diffs:\\\", self.external_diffs)\\n # print(\\\"base ssa:\\\", self.ch_model.ssa)\\n # print(\\\"ssa:\\\", ssa)\\n # print(\\\"other_ssa:\\\", other_ssa) # might throw error\\n yield ssa, other_ssa\\n\\n gen_next_ssa_pair_external_fixed = get_next_ssa_pair_external_fixed()\\n\\n for _ in range(max(1, num_external_samples)): # num_external_samples can be 0\\n num_right_inputs = 0\\n\\n if found_external_vars:\\n ssa, other_ssa = next(gen_next_ssa_pair_external_fixed)\\n # print(\\\"> ssa:\\\", ssa)\\n # print(\\\"> other_ssa:\\\", other_ssa)\\n\\n for pt, other_pt in get_next_input_pair():\\n if not found_external_vars: # func() faster than SSA.eval()\\n try:\\n ct, other_ct = self.ch_model.func(*pt), self.ch_model.func(*other_pt)\\n except ValueError as e:\\n if str(e).startswith(\\\"expected a tuple of Constant values returned\\\"):\\n # func might return redundant symbolic outputs (e.g., k ^ k = 0)\\n ct, other_ct = self.ch_model.ssa.eval(pt), self.ch_model.ssa.eval(other_pt)\\n else:\\n raise e\\n else:\\n ct, other_ct = ssa.eval(pt), other_ssa.eval(other_pt)\\n\\n for x in itertools.chain(ct, other_ct):\\n if not isinstance(x, core.Constant):\\n raise ValueError(f\\\"found symbolic output in ct={ct} or other_ct={other_ct}\\\")\\n\\n # print(\\\"pt, other_pt:\\\", pt, \\\"\\\\t\\\", other_pt)\\n # print(\\\"ct, other_ct:\\\", ct, \\\"\\\\t\\\", other_ct)\\n # print(\\\"expect diff:\\\", self.output_diff)\\n # print(\\\"diff found :\\\", [self.ch_model.diff_type.from_pair(ct[i], other_ct[i]) for i in range(len(ct))])\\n # print()\\n\\n for i, diff in enumerate(self.output_diff):\\n if self.ch_model.diff_type.from_pair(ct[i], other_ct[i]) != diff:\\n break\\n else:\\n num_right_inputs += 1\\n\\n aux_empirical_weights.append(\\n self._num_right_inputs2weight(num_right_inputs, num_input_samples)\\n )\\n\\n return aux_empirical_weights\",\n \"def train(self):\\n\\n for i in range(self.c):\\n mu_i = self.estimate_mu(i).T\\n cov_i = self.estimate_sigma(i, mu_i)\\n inv_sigma_i = np.linalg.inv(cov_i)\\n P_i = self.estimate_P(i)\\n Wi = -1 / 2 * inv_sigma_i\\n wi = inv_sigma_i @ mu_i\\n wi0 = -1 / 2 * mu_i.T @ inv_sigma_i @ mu_i - 1 / 2 * np.log(np.linalg.det(cov_i)) + np.log(P_i)\\n self.weights.append([Wi, wi, wi0])\\n return self.weights\",\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 get_prescribed_values(self):\\n \\n global_prescribed = []\\n list_prescribed_dofs = []\\n if self.frequencies is None:\\n number_frequencies = 1\\n else:\\n number_frequencies = len(self.frequencies)\\n \\n for node in self.preprocessor.nodes.values():\\n if node.there_are_prescribed_dofs:\\n global_prescribed.extend(node.get_prescribed_dofs_bc_values()) \\n\\n try: \\n \\n aux_ones = np.ones(number_frequencies, dtype=complex)\\n for value in global_prescribed:\\n if isinstance(value, complex):\\n list_prescribed_dofs.append(aux_ones*value)\\n elif isinstance(value, np.ndarray):\\n list_prescribed_dofs.append(value[0:number_frequencies])\\n array_prescribed_values = np.array(list_prescribed_dofs)\\n \\n except Exception as _error_log:\\n print(str(_error_log))\\n\\n return global_prescribed, array_prescribed_values\",\n \"def generateCoefficients (self):\\n\\t\\tself.ws = []\\n\\t\\tif not self.sine:\\n\\t\\t\\tself.bs = []\\n\\t\\tmean = np.zeros(self.dim)\\n\\t\\tcov = np.eye(self.dim)*(2*self.gammak)\\n\\n\\t\\tif self.sine:\\n\\t\\t\\tfor _ in range(self.rn):\\n\\t\\t\\t\\tself.ws.append(nr.multivariate_normal(mean, cov))\\n\\t\\telse:\\n\\t\\t\\tfor _ in range(self.rn):\\n\\t\\t\\t\\tself.ws.append(nr.multivariate_normal(mean, cov))\\n\\t\\t\\t\\tself.bs.append(nr.uniform(0.0, 2*np.pi))\",\n \"def samples(self):\\n return np.concatenate([wf.samples for wf in self._waveforms])\",\n \"def samples(self):\\n pass\",\n \"def wires(self):\\n return [o.wires for o in self.obs]\",\n \"def get_weights(self):\\n return [self.w, self.b]\",\n \"def _generate_distribution_samples(self, set_count, parameter_count):\\n self._samples = numpy.zeros((set_count, parameter_count))\\n for i, distribution in enumerate(self.parameter_distributions.values()):\\n self._samples[:, i] = distribution.ppf(self._quantiles[:, i])\",\n \"def get_weights(self):\\n return [self.W]\",\n \"def get_weights(self):\\n return [self.W]\",\n \"def _get_empirical_ch_weights_C(self, num_input_samples, num_external_samples, seed, num_parallel_processes,\\n verbose=False, get_sampled_inputs=False):\\n import uuid\\n from cascada.bitvector.printing import BvCCodePrinter\\n\\n assert not (verbose and get_sampled_inputs)\\n\\n assert 1 <= num_input_samples <= 2 ** sum(d.val.width for d in self.input_diff)\\n if self.external_diffs:\\n assert 1 <= num_external_samples <= 2 ** sum(d.val.width for d in self.external_diffs)\\n else:\\n assert num_external_samples == 0\\n\\n if num_input_samples.bit_length() > 64:\\n raise ValueError(\\\"max num_input_samples supported is 2**64 - 1\\\")\\n\\n width2C_type = BvCCodePrinter._width2C_type\\n get_and_mask_C_code = BvCCodePrinter._get_and_mask_C_code\\n\\n ctype_num_right_inputs = width2C_type(num_input_samples.bit_length())\\n\\n # 1 - Build the C code\\n\\n header = f\\\"{ctype_num_right_inputs} get_num_right_inputs(uint64_t seed);\\\"\\n\\n if hasattr(self.ch_model, \\\"_unwrapped_ch_model\\\"):\\n # avoid gcc error due to huge line statements\\n ssa = self.ch_model._unwrapped_ch_model.ssa\\n else:\\n ssa = self.ch_model.ssa\\n eval_ssa_code_function_name = \\\"eval_ssa\\\"\\n _, eval_ssa_code_body = ssa.get_C_code(eval_ssa_code_function_name) # ignore header\\n\\n from pathlib import Path\\n mt19937_filename = Path(__file__).parent.resolve() / \\\"mt19937.c\\\"\\n\\n def rand(my_width):\\n if my_width == 1:\\n rand_str = \\\"genrand64_int1\\\"\\n elif my_width <= 8:\\n rand_str = \\\"genrand64_int8\\\"\\n elif my_width <= 16:\\n rand_str = \\\"genrand64_int16\\\"\\n elif my_width <= 32:\\n rand_str = \\\"genrand64_int32\\\"\\n elif my_width <= 64:\\n rand_str = \\\"genrand64_int64\\\"\\n else:\\n raise ValueError(\\\"random bit-vectors with more than 64 bits are not supported\\\")\\n return f\\\"{rand_str}(){get_and_mask_C_code(var.width)}\\\"\\n\\n # stdint already in eval_ssa and in mt19937\\n body = f'#include \\\"{mt19937_filename}\\\"\\\\n{eval_ssa_code_body}'\\n body += f\\\"\\\\n{ctype_num_right_inputs} get_num_right_inputs(uint64_t seed){{\\\"\\n\\n to_sample_all_iv = num_input_samples == 2 ** sum(d.val.width for d in self.input_diff)\\n\\n if self.external_diffs or not to_sample_all_iv:\\n body += \\\"\\\\n\\\\tinit_genrand64(seed);\\\"\\n\\n body += f\\\"\\\\n\\\\t{ctype_num_right_inputs} num_right_inputs = 0U;\\\"\\n\\n # to_sample_all_ev cannot be used since get_num_right_inputs only returns 1 EW\\n if ssa.external_vars:\\n ev_other_names = [f\\\"{v.crepr()}_{uuid.uuid4().hex}\\\" for v in ssa.external_vars]\\n for i in range(len(ssa.external_vars)):\\n var = ssa.external_vars[i]\\n body += f\\\"\\\\n\\\\t{width2C_type(var.width)} {var.crepr()} = {rand(var.width)};\\\"\\n other_var = core.Variable(ev_other_names[i], var.width)\\n other_val = self.external_diffs[i].get_pair_element(var)\\n body += f\\\"\\\\n\\\\t{width2C_type(other_var.width)} {other_var.crepr()} = {other_val.crepr()};\\\"\\n if verbose:\\n body += f'\\\\n\\\\tprintf(\\\"\\\\\\\\nexternal_vars[%u] = (%x, %x)\\\", {i}U, {var.crepr()}, {other_var.crepr()});'\\n ev_args = ', '.join([v.crepr() for v in ssa.external_vars]) + \\\", \\\"\\n ev_other_args = ', '.join(ev_other_names) + \\\", \\\"\\n else:\\n ev_args = \\\"\\\"\\n ev_other_args = \\\"\\\"\\n\\n # start for\\n\\n if not to_sample_all_iv:\\n body += f\\\"\\\\n\\\\tfor ({ctype_num_right_inputs} i = 0U; i < {num_input_samples}U; ++i) {{\\\"\\n\\n iv_other_names = [f\\\"{v.crepr()}_{uuid.uuid4().hex}\\\" for v in ssa.input_vars]\\n for i in range(len(ssa.input_vars)):\\n var = ssa.input_vars[i]\\n if to_sample_all_iv:\\n v = var.crepr()\\n body += f\\\"\\\\n\\\\t\\\\tfor ({width2C_type(var.width+1)} {v} = 0U; {v} < {2**(var.width)}U; ++{v}) {{\\\"\\n else:\\n body += f\\\"\\\\n\\\\t\\\\t{width2C_type(var.width)} {var.crepr()} = {rand(var.width)};\\\"\\n other_var = core.Variable(iv_other_names[i], var.width)\\n other_val = self.input_diff[i].get_pair_element(var)\\n body += f\\\"\\\\n\\\\t\\\\t{width2C_type(other_var.width)} {other_var.crepr()} = {other_val.crepr()};\\\"\\n if verbose:\\n body += f'\\\\n\\\\t\\\\tprintf(\\\"\\\\\\\\ninput sample i=%u | input_vars[%u] = (%x, %x)\\\", ' \\\\\\n f'i, {i}U, {var.crepr()}, {other_var.crepr()});'\\n if get_sampled_inputs:\\n for i in range(len(ssa.input_vars)):\\n aux_prefix = \\\"[\\\" if i == 0 else \\\"\\\"\\n aux_suffix = \\\"],\\\" if i == len(ssa.input_vars) - 1 else \\\"\\\"\\n body += f'\\\\n\\\\t\\\\tprintf(\\\"{aux_prefix}0x%x,{aux_suffix}\\\", {ssa.input_vars[i].crepr()});'\\n iv_args = ', '.join([v.crepr() for v in ssa.input_vars])\\n iv_other_args = ', '.join(iv_other_names)\\n\\n ov_other_names = [f\\\"{v.crepr()}_{uuid.uuid4().hex}\\\" for v in ssa.output_vars]\\n for i in range(len(ssa.output_vars)):\\n var = ssa.output_vars[i]\\n other_var = core.Variable(ov_other_names[i], var.width)\\n # var passed by reference later (no need to declare them as pointers)\\n body += f\\\"\\\\n\\\\t\\\\t{width2C_type(var.width)} {var.crepr()}, {other_var.crepr()};\\\"\\n ov_args = ', '.join([\\\"&\\\" + v.crepr() for v in ssa.output_vars])\\n ov_other_args = ', '.join([\\\"&\\\" + name for name in ov_other_names])\\n\\n body += f\\\"\\\\n\\\\t\\\\t{eval_ssa_code_function_name}({iv_args}, {ev_args}{ov_args});\\\"\\n body += f\\\"\\\\n\\\\t\\\\t{eval_ssa_code_function_name}({iv_other_args}, {ev_other_args}{ov_other_args});\\\"\\n\\n if_conditions = []\\n for i in range(len(ssa.output_vars)):\\n var = ssa.output_vars[i]\\n other_var = core.Variable(ov_other_names[i], var.width)\\n current_d = self.ch_model.diff_type.from_pair(var, other_var).val\\n expected_d = self.output_diff[i].val\\n # casting current_d is necessary for the comparison\\n if_conditions.append(f\\\"( ({width2C_type(current_d.width)})({current_d.crepr()}) == {expected_d.crepr()} )\\\")\\n if verbose:\\n body += f'\\\\n\\\\t\\\\tprintf(\\\"\\\\\\\\n | output_vars[%u] = (%x, %x)\\\", ' \\\\\\n f'{i}U, {var.crepr()}, {other_var.crepr()});'\\n body += f'\\\\n\\\\t\\\\tprintf(\\\"\\\\\\\\n | current_expected[%u] = (%x, %x)\\\", ' \\\\\\n f'{i}U, {current_d.crepr()}, {expected_d.crepr()});'\\n body += f\\\"\\\\n\\\\t\\\\tif ( {' && '.join(if_conditions)} ){{\\\"\\n body += \\\"\\\\n\\\\t\\\\t\\\\tnum_right_inputs += 1U;\\\"\\n body += \\\"\\\\n\\\\t\\\\t}\\\"\\n\\n if to_sample_all_iv:\\n body += \\\"\\\\n\\\\t\\\\t\\\" + \\\"}\\\"*len(ssa.input_vars)\\n else:\\n body += \\\"\\\\n\\\\t}\\\"\\n\\n # end for\\n\\n if verbose:\\n body += f'\\\\n\\\\tprintf(\\\"\\\\\\\\nnum_right_inputs = %u\\\\\\\\n\\\", num_right_inputs);'\\n\\n body += \\\"\\\\n\\\\treturn num_right_inputs;\\\\n}\\\"\\n\\n # 2 - Run the C code\\n\\n if num_parallel_processes is None or num_external_samples <= 1:\\n pymod, tmpdir = cascada_ssa._compile_C_code(header, body, verbose=verbose)\\n\\n PRNG = random.Random()\\n PRNG.seed(seed)\\n\\n aux_empirical_weights = []\\n for _ in range(max(1, num_external_samples)): # num_external_samples can be 0\\n num_right_inputs = pymod.lib.get_num_right_inputs(PRNG.randrange(0, 2**64))\\n aux_empirical_weights.append(\\n self._num_right_inputs2weight(num_right_inputs, num_input_samples)\\n )\\n else:\\n lib_path, module_name, tmpdir = cascada_ssa._compile_C_code(header, body, return_unloaded=True, verbose=verbose)\\n\\n num_parallel_processes = min(num_parallel_processes, num_external_samples)\\n\\n PRNG = random.Random()\\n PRNG.seed(seed)\\n external_seeds = [PRNG.randrange(0, 2**64) for _ in range(num_external_samples)]\\n\\n chunk = num_external_samples // num_parallel_processes\\n if num_external_samples % num_parallel_processes == 0:\\n extra_chunk = 0\\n else:\\n extra_chunk = num_external_samples % num_parallel_processes\\n assert chunk*(num_parallel_processes-1) + chunk + extra_chunk == num_external_samples\\n\\n aux_empirical_weights = []\\n with multiprocessing.Pool(num_parallel_processes) as pool:\\n async_results = [None for _ in range(num_parallel_processes)]\\n for ar_index in range(len(async_results)):\\n async_results[ar_index] = pool.apply_async(\\n _run_C_code_get_num_right_inputs,\\n (\\n external_seeds[ar_index*chunk],\\n module_name,\\n lib_path,\\n chunk+extra_chunk if ar_index == len(async_results) - 1 else chunk\\n )\\n )\\n pool.close()\\n pool.join() # blocking call\\n for ar_index in range(len(async_results)):\\n # type(process_list[process_index]) == AsyncResult\\n # and AsyncResult.get() blocks until result obtained\\n list_num_right_inputs = async_results[ar_index].get()\\n aux_empirical_weights.extend(\\n [self._num_right_inputs2weight(nri, num_input_samples) for nri in list_num_right_inputs]\\n )\\n\\n assert len(aux_empirical_weights) == num_external_samples\\n\\n tmpdir.cleanup()\\n\\n return aux_empirical_weights\",\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 samples(self):\\n return self._norm_samples * self._scaling\",\n \"def get_weights(self):\\n return []\",\n \"def sample(self):\\n ret = []\\n for _ in range(self._count_dist_fn()):\\n ret.extend(self._pwm.sample())\\n return \\\"\\\".join(ret)\",\n \"def get_weights(self):\",\n \"def items():\\n for i in self._iter_restrict(zeros, ones):\\n yield self.pcdata[i]\",\n \"def one_basis(self):\\n return self._kbounded_partitions([])\",\n \"def gibbs(train_data, train_label, w_init, num_iterations, display_frequency, collect_final_sample_frequency): \\n dim = train_data.shape[1]\\n w_covariance = np.eye(dim) + np.sum(np.matmul(train_data[:, :, np.newaxis], train_data[:, np.newaxis, :]), axis= 0)\\n w_covariance = np.linalg.inv(w_covariance)\\n \\n w = w_init\\n _, z = get_output(w, train_data)\\n sigma = 1\\n \\n sampled = [] # Keeps track of all samples\\n final = [] # Keeps track of final samples which are sampled in a cyclic manner\\n\\n for i in range(num_iterations):\\n # Sample weight\\n w_new_mean = np.matmul(w_covariance, np.sum(z*train_data, axis= 0)[:, np.newaxis]) # dim x 1\\n w = np.random.multivariate_normal(w_new_mean[:, 0], w_covariance, 1).T # dim x 1\\n \\n # Now sample hidden variable\\n _, z_new = get_output(w, train_data)\\n lower= np.zeros((train_data.shape[0], 1))\\n upper= INFINITY*np.ones ((train_data.shape[0], 1)) \\n lower[train_label < 0.5, :] = -INFINITY\\n upper[train_label < 0.5, :] = 0\\n\\n\\n X = stats.truncnorm((lower - z_new) / sigma, (upper - z_new) / sigma, loc= z_new, scale= sigma) \\n z_new = X.rvs((train_data.shape[0],1))\\n \\n z = copy.deepcopy(z_new)\\n \\n if i % collect_final_sample_frequency == 0:\\n # Sample from the current parameters\\n final.append(w)\\n\\n if (i+1) % display_frequency == 0 or i == num_iterations-1:\\n print(\\\"Iter {:6d} done\\\".format(i+1))\\n \\n return np.array(final), w\",\n \"def get_weights(self):\\n if self.W_tickers is not None:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] + list(self.W_tickers.values())\\n if w is not None]\\n else:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] if w is not None]\",\n \"def get_weights(self):\\n if self.W_tickers is not None:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] + list(self.W_tickers.values())\\n if w is not None]\\n else:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] if w is not None]\",\n \"def get_weights(self):\\n if self.W_tickers is not None:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] + list(self.W_tickers.values())\\n if w is not None]\\n else:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc] if w is not None]\",\n \"def get_n_samples(self):\\n return {op.rx.get_n_samples() for op in self.ops}\",\n \"def sample_values(self, positions, gibbs):\\n \\\"\\\"\\\"Sample important values\\\"\\\"\\\"\\n\\n if gibbs:\\n self.local_energy = self.h.local_energy_gibbs(positions)\\n self.accumulate_energy += self.h.local_energy_gibbs(positions)\\n self.accumulate_energy_sq += self.local_energy*self.local_energy\\n gradient_wf_a = 0.5*self.w.gradient_wavefunction_a(positions)\\n gradient_wf_b = 0.5*self.w.gradient_wavefunction_b(positions)\\n gradient_wf_W = 0.5*self.w.gradient_wavefunction_W(positions)\\n else:\\n self.local_energy = self.h.local_energy(positions)\\n self.accumulate_energy += self.h.local_energy(positions)\\n self.accumulate_energy_sq += self.local_energy*self.local_energy\\n gradient_wf_a = self.w.gradient_wavefunction_a(positions)\\n gradient_wf_b = self.w.gradient_wavefunction_b(positions)\\n gradient_wf_W = self.w.gradient_wavefunction_W(positions)\\n # self.local_energy = self.h.local_energy_numerical(positions)\\n # self.accumulate_energy += self.h.local_energy_numerical(positions)\\n # gradient_wf_a = np.zeros(self.w.M)\\n # gradient_wf_b = np.zeros(self.w.N)\\n # gradient_wf_W = np.zeros((self.w.M, self.w.N))\\n\\n self.accumulate_psi_term_a += gradient_wf_a\\n self.accumulate_psi_term_b += gradient_wf_b\\n self.accumulate_psi_term_W += gradient_wf_W\\n self.accumulate_both_a += gradient_wf_a*self.local_energy\\n self.accumulate_both_b += gradient_wf_b*self.local_energy\\n self.accumulate_both_W += gradient_wf_W*self.local_energy\",\n \"def estimate(self, bases, freqs, **kwargs):\\n \\n # Make sure that frequencies are provided for every basis measured\\n if len(bases) != len(freqs):\\n print(\\\"Error, must provide frequency data for all bases measured.\\\")\\n return\\n\\n # Go through the keyword arguments and set mu and eps if required.\\n mu = 1e-4\\n eps = 0.1 \\n\\n if \\\"mu\\\" in kwargs:\\n mu = kwargs[\\\"mu\\\"]\\n if \\\"eps\\\" in kwargs:\\n eps = kwargs[\\\"eps\\\"]\\n\\n # Separate the bases out into measured and unmeasured\\n meas_bs_idx = []\\n unmeas_bs_idx = []\\n\\n for x in range(self.dim):\\n if x in bases:\\n meas_bs_idx.append(x)\\n else:\\n unmeas_bs_idx.append(x)\\n\\n # Handle the vertical slope separately\\n if -1 in bases:\\n meas_bs_idx.append(-1)\\n else:\\n unmeas_bs_idx.append(-1)\\n\\n # Begin with the initial state, the maximally mixed state\\n rho_0 = (1.0 / self.dim) * np.eye(self.dim)\\n rho_n = rho_0\\n\\n \\\"\\\"\\\"print(\\\"Measured bases are \\\", end = \\\"\\\")\\n print(meas_bs_idx)\\n print(\\\"Unmeasured bases are \\\", end = \\\"\\\")\\n print(unmeas_bs_idx)\\\"\\\"\\\"\\n \\n n = 1\\n\\n # Iterate\\n while (n):\\n ########################################################\\n # Compute W(rho)\\n # I might eventually put this in a separate method, but\\n # for now I'm going to leave it here to avoid having to\\n # repeatedly pass the same (large chunk of) information \\n # to some helper function.\\n ########################################################\\n term_1 = np.zeros((self.dim, self.dim))\\n term_2 = np.zeros((self.dim, self.dim))\\n\\n # Compute the first sum, which contains the measurement \\n # frequencies and the measured bases. Note that in theory\\n # the bases may not be in ascending order, however the \\n # frequencies will be generated in the same order as the \\n # bases are placed in the list. So create a separate counter\\n # for frequencies to just iterate through them one at a time\\n # as we go through the bases by their slope index.\\n freq_idx = 0 \\n for basis_idx in meas_bs_idx:\\n for proj_idx in range(self.dim):\\n this_projector = self.projectors[basis_idx][proj_idx]\\n\\n p_num = freqs[freq_idx][proj_idx] \\n p_denom = np.trace(np.dot(rho_n, this_projector))\\n prefactor = p_num / p_denom\\n\\n term_1 = term_1 + (prefactor * this_projector)\\n freq_idx += 1\\n\\n # If there are no unmeasured basis, do nothing\\n if len(unmeas_bs_idx) != 0:\\n # Compute the second sum, which is over all the unmeasured bases.\\n for basis_idx in unmeas_bs_idx:\\n for proj_idx in range(self.dim):\\n this_projector = self.projectors[basis_idx][proj_idx]\\n\\n prefactor = log(np.trace(np.dot(rho_n, this_projector)))\\n\\n term_2 = term_2 + (prefactor * this_projector)\\n \\n \\n # Finally, compute W(rho)\\n W_rho_n = term_1 - mu * term_2\\n ########################################################\\n\\n #print(\\\"n = \\\" + str(n))\\n #print(rho_n) \\n\\n # Check if we've got a good estimate. If the desired accuracy \\n # is satisfied by the most recent rho_n, then we're done. \\n # Return the estimator and the number of steps.\\n # If not, increment n and keep going.\\n if self.check_accuracy(W_rho_n, rho_n):\\n return rho_n, n \\n else:\\n n += 1\\n\\n # Compute the next term in the series. It's a big ugly expression,\\n # so I've separated out a term 'clump', and also the num/denom\\n clump = W_rho_n - np.trace(np.dot(W_rho_n, rho_n)) * np.eye(self.dim)\\n \\n numerator = np.dot(np.eye(self.dim) + eps * clump, \\\\\\n np.dot(rho_n, np.eye(self.dim) + eps * clump))\\n denominator = 1 + (eps ** 2) * np.trace(np.dot(np.dot(clump, clump), rho_n))\\n\\n rho_np1 = numerator / denominator\\n rho_n = rho_np1\",\n \"def return_weights(self):\\n w0 = self.comparator.weight.data.numpy()\\n b0 = self.comparator.bias.data.numpy()\\n\\n w1 = self.matcher.weight.data.numpy()\\n b1 = self.matcher.bias.data.numpy()\\n\\n w2 = self.head.weight.data.numpy()\\n b2 = self.head.bias.data.numpy()\\n\\n return w0, b0, w1, b1, w2, b2\",\n \"def get_random_wilson_coeffs_start(self):\\n if self.fit_wc_function is None:\\n # no Wilson coefficients present\\n return None\\n elif self.start_wc_priors is None:\\n if self.fit_wc_priors is None:\\n raise ValueError(\\\"Starting values can only be generated if\\\"\\n \\\" either fit_wc_priors or start_wc_priors is defined\\\")\\n else:\\n return self.get_random_wilson_coeffs\\n all_random = self.start_wc_priors.get_random_all()\\n return np.asarray([all_random[p] for p in self.fit_wc_names])\",\n \"def _compute_all(self) -> np.ndarray:\\n if self.acc.shape != self.gyr.shape:\\n raise ValueError(\\\"acc and gyr are not the same size\\\")\\n num_samples = len(self.acc)\\n Q = np.zeros((num_samples, 4))\\n # Compute with IMU architecture\\n if self.mag is None:\\n Q[0] = acc2q(self.acc[0]) if self.q0 is None else self.q0/np.linalg.norm(self.q0)\\n for t in range(1, num_samples):\\n Q[t] = self.updateIMU(Q[t-1], self.gyr[t], self.acc[t])\\n return Q\\n # Compute with MARG architecture\\n if self.mag.shape != self.gyr.shape:\\n raise ValueError(\\\"mag and gyr are not the same size\\\")\\n Q[0] = am2q(self.acc[0], self.mag[0]) if self.q0 is None else self.q0/np.linalg.norm(self.q0)\\n for t in range(1, num_samples):\\n Q[t] = self.updateMARG(Q[t-1], self.gyr[t], self.acc[t], self.mag[t])\\n return Q\",\n \"def extract_boft(self, min_freq=0.06, max_freq=0.66, bank=8, *args, **kwargs):\\n # First generate the wavelets\\n target_hz = self.sampling_freq\\n freqs = np.geomspace(min_freq, max_freq, bank)\\n wavs, hzs = [], []\\n for i, f in enumerate(freqs):\\n wav = np.real(wavelet(f, sampling_freq=target_hz))\\n wavs.append(wav)\\n hzs.append(str(np.round(freqs[i], 2)))\\n wavs = np.array(wavs)[::-1]\\n hzs = np.array(hzs)[::-1]\\n # # check asymptotes at lowest freq\\n # asym = wavs[-1,:10].sum()\\n # if asym > .001:\\n # print(\\\"Lowest frequency asymptotes at %2.8f \\\" %(wavs[-1,:10].sum()))\\n\\n # Convolve data with wavelets\\n Feats2Use = self.columns\\n feats = pd.DataFrame()\\n for feat in Feats2Use:\\n _d = self[[feat]].T\\n assert _d.isnull().sum().any() == 0, \\\"Data contains NaNs. Cannot convolve. \\\"\\n for iw, cm in enumerate(wavs):\\n convolved = np.apply_along_axis(\\n lambda m: np.convolve(m, cm, mode=\\\"full\\\"), axis=1, arr=_d.values\\n )\\n # Extract bin features.\\n out = pd.DataFrame(convolved.T).apply(calc_hist_auc, args=(None))\\n # 6 bins hardcoded from calc_hist_auc\\n colnames = [\\n \\\"pos\\\" + str(i) + \\\"_hz_\\\" + hzs[iw] + \\\"_\\\" + feat for i in range(6)\\n ]\\n colnames.extend(\\n [\\\"neg\\\" + str(i) + \\\"_hz_\\\" + hzs[iw] + \\\"_\\\" + feat for i in range(6)]\\n )\\n out = out.T\\n out.columns = colnames\\n feats = pd.concat([feats, out], axis=1)\\n return self.__class__(\\n feats, sampling_freq=self.sampling_freq, features=self.features\\n )\",\n \"def samples(self):\\n return self._samples\",\n \"def _compute_bare_spectrum_constant(self):\\n eigendata = []\\n for subsys in self._hilbertspace:\\n if subsys not in self.subsys_update_list:\\n evals_count = subsys.truncated_dim\\n eigendata.append(subsys.eigensys(evals_count=evals_count))\\n else:\\n eigendata.append(None)\\n return eigendata\",\n \"def distribution(self):\\n \\n #external_distribution serves both the purpose of external setting of distribution and the caching of distribution()\\n if self.external_distribution:\\n return self.external_distribution_array;\\n else:\\n energy_vector = []\\n superset = self.generate_superset(0) \\n \\n for i in superset:\\n state = self.ket(i)\\n \\n norm_squared = np.dot(state.T, state)\\n \\n if norm_squared > 0: #zero is appended at the end\\n energy = np.dot(state.T, np.dot( self.epsilon, state))\\n interaction = np.dot(state.T, np.dot( self.u, state))/2.0 #divide by two. Otherwise, <l r| U |l r > = U_LR + U_RL = 2U\\n #print state, np.dot(self.u, state) \\n #print interaction\\n energy_vector.append( energy + interaction )\\n \\n energy_vector.insert(0, 0.0) \\n probability = np.exp( np.multiply(-self.beta, energy_vector)) \\n probability /= probability.sum() \\n return probability\",\n \"def initial_sampling(self, params):\\n i = params\\n theta_star = self.priors_sample()\\n model = self.simz( theta_star )\\n rho = test_dist(self.data, model)\\n while rho > self.eps0: \\n theta_star = self.priors_sample()\\n model = self.simz( theta_star )\\n rho = test_dist(self.data, model)\\n data_list = [np.int(i)]\\n\\n for i_param in xrange(self.n_params): \\n data_list.append(theta_star[i_param])\\n data_list.append(1./np.float(self.N))\\n data_list.append(rho)\\n\\treturn np.array(data_list)\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def _compute_bare_spectrum_constant(self) -> List[Tuple[ndarray, ndarray]]:\\n eigendata = []\\n for subsys in self._hilbertspace:\\n if subsys not in self.subsys_update_list:\\n evals_count = subsys.truncated_dim\\n eigendata.append(subsys.eigensys(evals_count=evals_count))\\n else:\\n eigendata.append(None) # type: ignore\\n return eigendata\",\n \"def generate(self) -> np.ndarray:\\n self.sample_r()\\n self.sample_z()\\n ind: np.ndarray = np.less_equal(self.z_sample, self.r_sample)\\n self.r_sample = self.r_sample[ind]\\n self.z_sample = self.z_sample[ind]\\n return np.sort(np.sqrt(np.subtract(np.square(self.r_sample), np.square(self.z_sample))))\",\n \"def get_samples(self) -> McmcPtResult:\",\n \"def samples(self):\\n if len(self._samples) == 0:\\n return np.empty((0, 2))\\n return self._samples\",\n \"def _generate_weights(self):\\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\\n return self._normalize_weights(weights)\",\n \"def generate_basis(n, dim):\\n planes = [np.random.randn(dim) for i in range(n)]\\n return [p / np.linalg.norm(p) for p in planes]\",\n \"def get_weights(self):\\n if self.W_tickers is not None:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc, self.W_red_rec] + list(self.W_tickers.values())\\n if w is not None]\\n else:\\n return [w for w in [self.W_fwd_conc, self.W_bwd_conc, self.W_red_rec] if w is not None]\",\n \"def initSamples(self):\\n # Define this (note random.uniform is helpful here!)\\n for i in range(self.numParticles):\\n # Create particles uniformly and generate same weights for all particles.\\n particle = random.uniform(self.minValue, self.maxValue)\\n self.samples.append(particle)\\n self.weights.append(1/self.numParticles)\",\n \"def gen_energies(n_muons):\\r\\n pdist, bounds = fit_energylaw()\\r\\n samples = monte_carlo_sample(pdist, bounds, n_muons)\\r\\n return samples\",\n \"def _get_sample(self):\\n return [layer._get_sample() for layer in self.layers]\",\n \"def getAllSpectrumMeasurements(self): \\n return self.spectrum\",\n \"def _gibbs_sampling_iteration(self):\\n for m, dm in enumerate(self.corpus):\\n for n, w_mn in enumerate(dm):\\n k = self.z_mn[m, n]\\n self.n_mk[m, k] -= 1\\n self.n_m[m] -= 1\\n self.n_kt[k, w_mn] -= 1\\n self.n_k[k] -= 1\\n k = self._conditional_z(\\n self.n_components, self.alpha, self.beta,\\n self.n_mk, self.n_kt, m, w_mn, self.beta_sum, self.n_k)\\n self.z_mn[m, n] = k\\n self.n_mk[m, k] += 1\\n self.n_m[m] += 1\\n self.n_kt[k, w_mn] += 1\\n self.n_k[k] += 1\",\n \"def heisenberg_obs(self, num_wires):\\n p = self.parameters\\n U = self._heisenberg_rep(p) # pylint: disable=assignment-from-none\\n return self.heisenberg_expand(U, num_wires)\",\n \"def x(self):\\n return UnweightedSamples(self.particles)\",\n \"def circuit():\\n np.random.seed(1967)\\n for gates in gates_per_layers:\\n for gate in gates:\\n qml.apply(gate)\\n return qml.expval(qml.PauliZ(0))\",\n \"def waveforms(self):\\n return list(self._waveforms)\",\n \"def make_wavetables(kernel: GPy.kern.Kern, n: int = 17, waveshaping: bool = False) -> List[np.ndarray]:\\n wavetables = []\\n\\n if not waveshaping:\\n cholesky = make_cov_cholesky(kernel)\\n else:\\n cholesky = make_cov_cholesky_waveshaping(kernel)\\n for _ in range(n):\\n wavetable = fast_normal_from_cholesky(cholesky)[0]\\n wavetables.append(wavetable[:-1])\\n\\n return wavetables\",\n \"def fock_basis(self):\\n return combinations_with_replacement(range(self.N), self.photon_number)\",\n \"def realizations(Wsize, gamma, radius, n=100):\\n W = np.zeros((n, 3))\\n areaWsize = Wsize[0] * Wsize[1]\\n bar = progressbar.ProgressBar()\\n for i in bar(range(n)):\\n Z = booleanModel(Wsize, gamma, radius)\\n a, p, chi8, chi4 = minkowskiFunctionals(Z)\\n W[i, :] = np.array([a, p/2, chi8*np.pi]) / areaWsize\\n\\n return W\",\n \"def __next__(self):\\n blend_tables = []\\n for _ in range(self.batch_size):\\n blend_table = self.sampling_function(self.catalog.table)\\n self._check_n_sources(blend_table)\\n blend_tables.append(blend_table)\\n return blend_tables\",\n \"def ws(self, inhom_object):\\n z = inhom_object.zeta\\n # define bohr frequencies of eigenstates--currently a and b are \\n # correlated \\n wg = 0.0 + 0*z\\n wa = z + self.wa_central\\n wb = z + self.wb_central\\n w2a = 2*wa - self.a_coupling\\n w2b = 2*wb - self.b_coupling\\n wc = wa + wb - self.ab_coupling\\n # define coherence frequencies\\n w_gg = wg - wg\\n w_ag = wa - wg\\n w_bg = wb - wg\\n w_2ag = w2a - wg\\n w_2bg = w2b - wg\\n w_cg = wc - wg\\n # array aggregates all frequencies to match state vectors\\n w = np.array( [w_gg, \\n w_ag, w_bg,\\n w_2ag, w_2bg, w_cg\\n ])\\n return w\",\n \"def weights(self) -> List[float]:\",\n \"def generate_samples(self, Nt, model=None, exe=0, ret_base ='binary'):\\n if Nt == 0:\\n print('Error: Nt must be greater than 0')\\n return\\n Nt = int(Nt)\\n\\n # establish an annealing factors array which contains all annealing related information to be sent to cpsl/ppsl\\n annealing_factors = np.asarray([self.beta, self.start_beta, self.end_beta, self.growth_factor])\\n\\n # jit requires specific input types\\n jit_beta = float64(self.beta)\\n jit_m = float64(self.m)\\n jit_J = np.ndarray.flatten(np.ndarray.astype(self.J, \\\"float64\\\"))\\n jit_h = np.ndarray.flatten(np.ndarray.astype(self.h, \\\"float64\\\"))\\n jit_Nm = np.int64(self.Nm)\\n jit_rand = np.random.uniform(-1, 1, Nt * self.Nm)\\n\\n\\n if model is None:\\n model = self.model\\n if model == \\\"cpsl\\\":\\n if exe == 0:\\n m_all = _cpsl(self.m, self.Nm, self.J, self.h, Nt, self.anneal, annealing_factors)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n elif exe == 1:\\n m_all = _cpsl_fast(jit_m, jit_Nm, jit_J, jit_h, Nt, jit_rand, self.beta)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n else:\\n # gpu requires sending variables\\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\\n cpu_samples = np.zeros((Nt, self.Nm))\\n rand_vals = jit_rand\\n\\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\\n gpu_samples = cp.asarray(cpu_samples)\\n gpu_J = cp.asarray(self.J)\\n gpu_h = cp.asarray(self.h)\\n gpu_m = cp.asarray(self.m)\\n gpu_rand_vals = cp.asarray(rand_vals)\\n\\n _cpsl_core_gpu(cpu_samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\\n m_all = cpu_samples\\n self.m = m_all[Nt - 1, :]\\n elif model == \\\"ppsl\\\":\\n if exe == 1 or exe == 0:\\n m_all = _ppsl_fast(jit_m, jit_Nm, jit_J, jit_h, jit_beta, Nt, self.dt, jit_rand)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n else:\\n # gpu requires sending variables\\n\\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\\n samples = np.zeros((Nt, self.Nm))\\n rand_vals = jit_rand\\n\\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\\n gpu_samples = cp.asarray(samples)\\n gpu_J = cp.asarray(self.J)\\n gpu_h = cp.asarray(self.h)\\n gpu_m = cp.asarray(self.m)\\n gpu_rand_vals = cp.asarray(rand_vals)\\n _ppsl_core_gpu(samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\\n m_all = samples\\n self.m = m_all[Nt - 1, :]\\n else:\\n print(\\\"Error: unknown model\\\")\\n\\n if ret_base == 'samples' or ret_base == 'sample' or ret_base == 'b' or ret_base == 'binary' or ret_base == 2:\\n return m_all\\n elif ret_base == 'decimal' or ret_base == 'd' or ret_base == 'deci' or ret_base == 'decimals' or ret_base == 10:\\n return bi_arr2de(m_all)\",\n \"def get_random(self):\\n arr = np.zeros(self.dimension)\\n n_fit_p = len(self.fit_parameters)\\n n_nui_p = len(self.nuisance_parameters)\\n arr[:n_fit_p] = self.get_random_fit_parameters\\n arr[n_fit_p:n_fit_p+n_nui_p] = self.get_random_nuisance_parameters\\n arr[n_fit_p+n_nui_p:] = self.get_random_wilson_coeffs\\n return arr\",\n \"def weights(self):\\n \\n n = self.n\\n lambda_ = self.alpha**2 * (n +self.kappa) - n\\n \\n c = .5 / (n + lambda_)\\n Wc = np.full(2*n + 1, c)\\n Wm = np.full(2*n + 1, c)\\n Wc[0] = lambda_ / (n + lambda_) + (1 - self.alpha**2 + self.beta)\\n Wm[0] = lambda_ / (n + lambda_)\\n \\n return Wm, Wc\",\n \"def get_bandpowers(\\n self,\\n map_tag=None,\\n converge_criteria=0.005,\\n iter_max=200,\\n return_qb=False,\\n save_iters=False,\\n delta_beta_prior=None,\\n cond_noise=None,\\n cond_criteria=None,\\n null_first_cmb=False,\\n return_cls=False,\\n like_profiles=False,\\n like_profile_sigma=3.0,\\n like_profile_points=100,\\n file_tag=None,\\n ):\\n\\n save_name = \\\"bandpowers\\\"\\n\\n fish_shape = (len(pt.dict_to_arr(self.bin_def)),) * 2\\n\\n # check all options that require rerunning fisher iterations\\n opts = dict(\\n converge_criteria=converge_criteria,\\n cond_noise=cond_noise,\\n cond_criteria=cond_criteria,\\n null_first_cmb=null_first_cmb,\\n apply_gcorr=self.apply_gcorr,\\n weighted_bins=self.weighted_bins,\\n )\\n if \\\"fg_tt\\\" in self.bin_def:\\n opts.update(\\n delta_beta_prior=delta_beta_prior,\\n ref_freq=self.ref_freq,\\n beta_ref=self.beta_ref,\\n )\\n if self.template_cleaned:\\n opts.update(template_alpha=self.template_alpha)\\n self.return_cls = return_cls\\n\\n ret = self.load_data(\\n save_name,\\n \\\"bandpowers\\\",\\n bp_opts=True,\\n to_attrs=False,\\n shape=fish_shape,\\n shape_ref=\\\"inv_fish\\\",\\n map_tag=map_tag,\\n value_ref=opts,\\n extra_tag=file_tag,\\n )\\n if ret is not None:\\n if return_qb:\\n return ret[\\\"qb\\\"], ret[\\\"inv_fish\\\"]\\n return ret\\n\\n self.clear_precalc()\\n\\n cbl = self.bin_cl_template(map_tag=map_tag, transfer_run=False)\\n\\n ret = self.fisher_iterate(\\n cbl,\\n map_tag,\\n transfer_run=False,\\n iter_max=iter_max,\\n converge_criteria=converge_criteria,\\n save_iters=save_iters,\\n cond_noise=cond_noise,\\n cond_criteria=cond_criteria,\\n null_first_cmb=null_first_cmb,\\n delta_beta_prior=delta_beta_prior,\\n like_profiles=like_profiles,\\n like_profile_sigma=like_profile_sigma,\\n like_profile_points=like_profile_points,\\n file_tag=file_tag,\\n )\\n\\n if not ret[\\\"success\\\"]:\\n raise RuntimeError(\\\"Error computing bandpowers\\\")\\n\\n # return\\n if return_qb:\\n return ret[\\\"qb\\\"], ret[\\\"inv_fish\\\"]\\n return ret\",\n \"def calculateObservables(N, temp, thermalizationSteps=50, simulationSteps=100, skipSweeps=5, bootstrapM=500):\\n\\n # Where we will store the magnetizations and energies\\n magnetizationArr = np.zeros(simulationSteps)\\n energyArr = np.zeros(simulationSteps)\\n\\n # This isn't really a variable since the Wolff method requires h = 0,\\n # but I'll define it to make the formulas be more verbose\\n # That being said ****DO NOT CHANGE THIS****\\n h = 0\\n\\n # Generate our initial conditions\\n # Use cold start, but it shouldn't matter since we thermalize\\n isingMap = Ising.initializeCold(N)\\n \\n # Thermalize\\n for i in range(thermalizationSteps):\\n Ising.singleClusterFlip(isingMap, 1/temp) \\n\\n # Now we'll actually record data\\n for i in range(simulationSteps):\\n # Note that this magnetization is not the magnitization per site, so\\n # we have to divide by a factor of N later on\\n magnetizationArr[i] = Ising.magnetization(isingMap)\\n\\n # This is indeed the energy density, and therefore we multiply by a\\n # factor of N later on as opposed to the magnetization above\\n energyArr[i] = Ising.energyDensity(isingMap, h)\\n\\n # Skip a few steps to reduce the correlation between successive measurements\\n for j in range(skipSweeps):\\n Ising.singleClusterFlip(isingMap, 1/temp)\\n\\n\\n # The variance in the magnetization should be proportional to the susceptability\\n magnetizationVariance = Ising.statisticalBootstrap(magnetizationArr, np.var, bootstrapM)\\n # The variance in the energy should be proportional to the specific heat\\n energyVariance = Ising.statisticalBootstrap(energyArr, np.var, bootstrapM)\\n\\n # These constants out front are questionable, but in general were taken from\\n # https://www.maths.tcd.ie/~bouracha/reports/2-dimensional_ising_model.pdf\\n # Because of this uncertainty, we opted to solve for alpha and nu, since they\\n # don't depend on the magnitude of the peaks, only their positions\\n chi = (1/N**2) * 1/temp * magnetizationVariance\\n C = N**2 * (1/temp)**2 * energyVariance\\n\\n return [C, chi]\",\n \"def _generate_weights(self):\\n weights = []\\n for i in range(1, len(self.layers) - 1):\\n weights.append(2 * np.random.random(\\n (self.layers[i - 1] + 1, self.layers[i] + 1)) - 1)\\n weights.append(2 * np.random.random(\\n (self.layers[i] + 1, self.layers[i + 1])) - 1)\\n return weights\",\n \"def generate_sample(self):\\n\\n sample_one = np.zeros(self.n_dimensions)\\n\\n \\\"\\\"\\\"C: Huge gains here from using numpy functions at once instead of a Python loop\\\"\\\"\\\"\\n \\\"\\\"\\\"S: How..?\\\"\\\"\\\"\\n\\n for i in range(self.n_dimensions):\\n self.Y[i] ^= self.V[\\n self.index_of_least_significant_zero_bit(self.current - 1), i\\n ]\\n sample_one[i] = float(self.Y[i] / math.pow(2, self.scale))\\n self.current += 1\\n return sample_one\",\n \"def batch_calculate_sampled_expectation(circuits, param_resolvers, ops,\\n n_samples, sampler):\\n _validate_inputs(circuits, param_resolvers, sampler, 'sample')\\n if _check_empty(circuits):\\n return np.zeros((0, 0), dtype=np.float32)\\n\\n if not isinstance(ops, (list, tuple, np.ndarray)):\\n raise TypeError('ops must be a list or array.'\\n ' Given: {}'.format(type(ops)))\\n\\n if len(ops) != len(circuits):\\n raise ValueError('Shape of ops and circuits do not match.')\\n\\n if len(n_samples) != len(circuits):\\n raise ValueError('Shape of n_samples does not match circuits.')\\n\\n for sub_list in n_samples:\\n if not isinstance(sub_list, (list, tuple, np.ndarray)):\\n raise TypeError('Elements of n_elements must be lists of ints.')\\n for x in sub_list:\\n if not isinstance(x, int):\\n raise TypeError('Non-integer value found in n_samples.')\\n if x <= 0:\\n raise ValueError('n_samples contains sample value <= 0.')\\n\\n for sub_list in ops:\\n if not isinstance(sub_list, (list, tuple, np.ndarray)):\\n raise TypeError('elements of ops must be type list.')\\n for x in sub_list:\\n if not isinstance(x, cirq.PauliSum):\\n raise TypeError('ops must contain only cirq.PauliSum objects.'\\n ' Given: {}'.format(type(x)))\\n\\n all_exp_vals = np.full((len(circuits), len(ops[0])), -2, dtype=np.float32)\\n\\n for c_index, (c, params) in enumerate(zip(circuits, param_resolvers)):\\n # (#679) Just ignore empty programs.\\n if len(c.all_qubits()) == 0:\\n continue\\n circuit = cirq.resolve_parameters(c, params)\\n for op_index, op in enumerate(ops[c_index]):\\n collector = TFQPauliSumCollector(\\n circuit, op, samples_per_term=n_samples[c_index][op_index])\\n collector.collect(sampler)\\n result = collector.estimated_energy().real\\n all_exp_vals[c_index][op_index] = result\\n\\n return all_exp_vals\",\n \"def _get_all(cls) -> Iterator[\\\"PermutationStatistic\\\"]:\\n yield from (cls(name, func) for name, func in PermutationStatistic._STATISTICS)\",\n \"def generate_samples(self, n_samples=100):\\n \\t\\t\\n\\t\\t#how many times should ancestral sampling be run\\n\\t\\t#n_samples\\n prior_samples=[]\\n for i in range(0,n_samples):\\n prior_sample = self.prior.get_samples(\\n n_latent_nodes=self.n_latent_nodes,\\n n_gibbs_sampling_steps=100, \\n sampling_mode=\\\"gibbs_ancestral\\\")\\n prior_sample = torch.cat(prior_sample)\\n prior_samples.append(prior_sample)\\n prior_samples=torch.stack(prior_samples)\\n # prior_samples = tf.slice(prior_samples, [0, 0], [num_samples, -1])\\n output_activations = self.decoder.decode(prior_samples)\\n output_activations = output_activations+self._train_bias\\n output_distribution = Bernoulli(logit=output_activations)\\n output=torch.sigmoid(output_distribution.logits)\\n # output_activations[0] = output_activations[0] + self.train_bias\\n # output_dist = FactorialBernoulliUtil(output_activations)\\n # output_samples = tf.nn.sigmoid(output_dist.logit_mu)\\n # print(\\\"--- \\\",\\\"end VAE::generate_samples()\\\")\\n return output\",\n \"def compute_all(self) -> None:\\n self.compute_j_matrix()\\n self.compute_outter_distribution()\\n self.compute_max_prior()\\n self.compute_max_poutter()\",\n \"def get_gaba_examples_supp(self):\\n return np.broadcast_to(\\n self.get_t_vec(),\\n self.gaba_examples[self.gaba_examples.keys()[0]].shape,\\n )\",\n \"def u_weights(self):\\n for i in range(self.n_inputs):\\n self._q_neuron.cx(self._weights[i], self.inputs[i])\",\n \"def getBasis(self):\\n return self.__basis\",\n \"def compute_disturbances_bootstrap_rawdata(n_bits, data_ref, data_test, num_bootstrap_samples=20,\\n max_weight=4, solver=\\\"SCS\\\", verbosity=1, seed=0,\\n return_resampled_data=False, add_one_to_data=True):\\n #p_ml = _np.array(data_ref) / _np.sum(data_ref)\\n #q_ml = _np.array(data_test) / _np.sum(data_test)\\n\\n if verbosity > 0:\\n print(\\\"Computing base disturbances\\\")\\n dist_by_weight_ml = compute_disturbances_with_confidence(\\n n_bits, data_ref, data_test, None, max_weight, solver=solver, verbosity=verbosity - 1)\\n\\n dist_by_weight = _np.zeros((max_weight, num_bootstrap_samples), 'd')\\n resampled_data = []\\n\\n bootstrap_data_ref = data_ref + _np.ones(len(data_ref), dtype='int')\\n bootstrap_data_test = data_test + _np.ones(len(data_test), dtype='int')\\n\\n for i in range(num_bootstrap_samples):\\n if verbosity > 0:\\n print(\\\"Analyzing bootstrap sample %d of %d...\\\" % (i + 1, num_bootstrap_samples), end='')\\n _sys.stdout.flush(); tStart = _time.time()\\n redata_ref = resample_data(bootstrap_data_ref, seed=seed + i)\\n redata_test = resample_data(bootstrap_data_test, seed=seed + num_bootstrap_samples + i)\\n if return_resampled_data:\\n resampled_data.append((redata_ref, redata_test))\\n\\n try:\\n disturbances = compute_disturbances_with_confidence(\\n n_bits, redata_ref, redata_test, None, max_weight, solver=solver, verbosity=verbosity - 2)\\n except Exception:\\n try:\\n if verbosity > 0: print(\\\"\\\\nFalling back on ECOS\\\")\\n disturbances = compute_disturbances_with_confidence(\\n n_bits, redata_ref, redata_test, None, max_weight, solver=\\\"ECOS\\\", verbosity=verbosity - 2)\\n except Exception:\\n if verbosity > 0: print(\\\"\\\\nFailed using %s and ECOS - reporting nans\\\" % solver)\\n for w in range(max_weight):\\n dist_by_weight[w, i] = _np.nan\\n\\n for w in range(max_weight):\\n dist_by_weight[w, i] = disturbances[w][0]\\n\\n if verbosity > 0:\\n print(\\\" (%.1fs)\\\" % (_time.time() - tStart))\\n\\n dist_ml = _np.array([dist_by_weight_ml[w][0] for w in range(max_weight)], 'd')\\n\\n if return_resampled_data:\\n return dist_ml, dist_by_weight, resampled_data\\n else:\\n return dist_ml, dist_by_weight\",\n \"def probability_array(self):\\n q = self.apply_weights()\\n return np.exp(q)/(1 + np.exp(q))\",\n \"def samples(self):\\n if self._samples:\\n return self._samples\\n if SAMPLE_DF_KEY not in self or self[SAMPLE_DF_KEY] is None:\\n _LOGGER.debug(\\\"No samples are defined\\\")\\n return []\",\n \"def get_weights(self):\\n return self.weights\\n #print(W)\",\n \"def _build_basis_slow(weight, n_bits):\\n _warnings.warn((\\\"You're using a slow version of the basis-building code used by the disturbance calculations\\\"\\n \\\" - compile pyGSTi's C extensions to make this go faster.\\\"))\\n n_w = n_parameters_per_matrix(weight, n_bits)\\n n_a = n_matrices_per_weight(weight, n_bits)\\n dim = 2**n_bits\\n\\n my_basis = []\\n my_constraints = []\\n # All sets of qubits of given weight on n_bits\\n pairs = list(_itertools.combinations(_np.arange(n_bits), weight))\\n\\n for ind in range(n_w * n_a):\\n v = unit_vector(ind, n_w * n_a)\\n vs = _np.reshape(v, (n_a, n_w))\\n ctm = sum((swell_slow(transition_matrix(v, 2**weight), pair, n_bits)\\n for v, pair in zip(vs, pairs))) - n_a * _np.eye(dim)\\n my_basis += [ctm]\\n my_constraints += [-_np.diag(ctm)]\\n\\n return my_basis, _np.array(my_constraints, dtype='int').T\",\n \"def whatareks():\\n\\n print(\\\"loading data\\\")\\n dataset = datagen.DataSet(datapath)\\n dataset.load()\\n\\n for k, ens in enumerate(dataset.ensembles):\\n\\n print(\\n f\\\"k: {k} --> b={ens.b}, N={ens.grid_shape[0]}, iternum={ens.iternum}\\\")\",\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 frequencyEstimator(ctd, ladcp, bathy, rho_neutral, strain,\\\\\\n wl_min=100, wl_max=500, full_set=False):\\n \\n U, V, p_ladcp = oc.loadLADCP(ladcp)\\n S, T, p_ctd, lat, lon = oc.loadCTD(ctd)\\n \\n \\n Ek, Ep, Etotal, eta_power,\\\\\\n Upow, Vpow, UVkx, eta_kx,\\\\\\n N2mean, wl_min, wl_max,\\\\\\n dist, depths, U, V, p_ladcp,\\\\\\n Uspec, Vspec, etaSpec =\\\\\\n internal_wave_energy(ctd, ladcp,\\\\\\n rho_neutral,\\\\\\n bathy, strain, wl_min=wl_min, wl_max=wl_max)\\n \\n eta_power_export = np.vstack(eta_power)\\n eta_kx_export = np.vstack(eta_kx)\\n Up_export = np.vstack(Upow)\\n Vp_export = np.vstack(Vpow)\\n UVkx_export = np.vstack(UVkx)\\n \\n\\n np.savetxt('eta_power.csv',eta_power_export)\\n np.savetxt('eta_kx.csv',eta_kx_export)\\n np.savetxt('Upow.csv',Up_export)\\n np.savetxt('Vpow.csv',Vp_export)\\n np.savetxt('UVkx.csv',UVkx_export)\\n\\n\\n \\n \\n # look for wavenumber maxes\\n \\n \\n # Use ratios to solve for internal frequncys\\n f = np.nanmean(gsw.f(lat))\\n \\n omega = f*np.sqrt(Etotal/(Ek-Ep))\\n\\n m = np.mean((wl_min, wl_max))\\n m = (2*np.pi)/m\\n kh = (m/np.sqrt(np.abs(N2mean)))*(np.sqrt(omega**2 - f**2))\\n mask = kh == 0\\n kh[mask]= np.nan\\n lambdaH = 1e-3*(2*np.pi)/kh\\n \\n # get mean spectra\\\\\\n \\n eta_mean = []\\n for station in eta_power:\\n eta_mean.append(np.nanmean(station, axis=0))\\n \\n eta_mean = np.vstack(eta_mean).T\\n \\n \\n aspect = kh/m \\n \\n file2save = pd.DataFrame(lambdaH)\\n file2save.index = np.squeeze(depths)\\n file2save.to_excel('lambdaH.xlsx')\\n file2save = pd.DataFrame(kh)\\n file2save.index = np.squeeze(depths)\\n file2save.to_excel('Kh.xlsx')\\n file2save = pd.DataFrame(omega)\\n file2save.index = np.squeeze(depths)\\n file2save.to_excel('omega.xlsx')\\n file2save = pd.DataFrame(aspect)\\n file2save.index = np.squeeze(depths)\\n file2save.to_excel('aspect.xlsx')\\n \\n np.savetxt('eta_mean.csv', eta_mean)\\n \\n \\n np.savetxt('kh.csv', kh)\\n np.savetxt('lamdah.csv', lambdaH)\\n np.savetxt('omega.csv', omega)\\n \\n if full_set:\\n return lambdaH, kh, omega, N2mean,\\\\\\n dist, depths, U, V, p_ladcp,\\\\\\n Uspec, Vspec, etaSpec, aspect\\n \\n else:\\n return lambdaH, kh, omega, N2mean\",\n \"def get_all_mutagens(self):\\n return [self.learning_rate, self.beta1, self.beta2, self.weight_init]\",\n \"def fetch_samples(self):\\n return torch.cat(self.samples,dim=0).reshape(-1,self.parameters.numel())\",\n \"def build_basis(self):\\n if self.debug:\\n print('sps_basis: rebuilding basis')\\n # Setup the internal component basis arrays\\n inwave = self.ssp.wavelengths\\n nbasis = len(np.atleast_1d(self.params['mass']))\\n self.nbasis = nbasis\\n # nbasis = ( len(np.atleast_1d(self.params['zmet'])) *\\n # len(np.atleast_1d(self.params['tage'])) )\\n self.basis_spec = np.zeros([nbasis, len(inwave)])\\n self.basis_mass = np.zeros(nbasis)\\n\\n i = 0\\n tesc = self.params['dust_tesc']\\n dust1, dust2 = self.params['dust1'], self.params['dust2']\\n for j, zmet in enumerate(self.params['zmet']):\\n for k, tage in enumerate(self.params['tage']):\\n # get the intrinsic spectrum at this metallicity and age\\n if self.safe:\\n # do it using compsp\\n if self.ssp._zcontinuous > 0:\\n self.ssp.params['logzsol'] = zmet\\n else:\\n self.ssp.params['zmet'] = zmet\\n w, spec = self.ssp.get_spectrum(tage=tage, peraa=True)\\n mass = self.ssp.stellar_mass\\n else:\\n # do it by hand. Faster but dangerous\\n spec, mass, lbol = self.ssp.ztinterp(zmet, tage, peraa=True)\\n self.basis_spec[i, :] = spec\\n self.basis_mass[i] = mass\\n i += 1\\n self.basis_dirty = False\",\n \"def test_custom_wsr(self):\\n def _wsr_gen(num_bits):\\n nonlocal gen_wsr\\n gen_wsr = [1]*num_bits\\n return gen_wsr\\n\\n gen_wsr = None\\n generator = Generator(backend=FakeValencia(), wsr_generator=_wsr_gen)\\n job = generator.sample(num_raw_bits=100)\\n self.assertEqual(job.initial_wsr, gen_wsr)\",\n \"def one_basis(self):\\n # FIXME: this method should be conditionaly defined,\\n # so that B.one_basis returns NotImplemented if not\\n # all modules provide one_basis\\n if all(hasattr(module, \\\"one_basis\\\") for module in self._sets):\\n return tuple(module.one_basis() for module in self._sets)\\n else:\\n raise NotImplementedError\",\n \"def iterWeights(self):\\r\\n\\t\\tyield None\",\n \"def probed_basis(self):\\n return self._pre_kernel * self.number_of_basis\",\n \"def getWaveform(self, ch=\\\"CH1\\\", samples=2500):\\n\\t\\tself.isReady()\\n\\t\\tcounter = 1\\n\\t\\twhile True:\\n\\t\\t\\ttry:\\t\\t\\n\\t\\t\\t\\twaveform = self.osc.get_waveform(source = ch, start = 1, stop = samples)\\n\\t\\t\\t\\tbreak\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tprint(\\\"Retry: \\\" + str(counter))\\n\\t\\t\\t\\tcounter += 1\\n\\t\\ty_array = []\\n\\t\\tfor x,y in waveform:\\n\\t\\t\\ty_array.append(y)\\n\\t\\treturn y_array\",\n \"def get_weights(self):\\n return self.w\",\n \"def get_weights(self):\\n return self.w\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6354442","0.6312051","0.6045636","0.5982405","0.5920717","0.58340013","0.57912403","0.5770052","0.5703894","0.5652854","0.5625554","0.5597974","0.5590781","0.5573974","0.5573084","0.5562036","0.55604845","0.55475634","0.55385345","0.552718","0.552718","0.5526244","0.55233794","0.5521452","0.5500657","0.54848874","0.54796004","0.5433063","0.54319966","0.5410045","0.5409456","0.5409456","0.5409456","0.54083014","0.54032725","0.5388008","0.53760797","0.53703284","0.5366612","0.5365515","0.5361175","0.5353246","0.53477454","0.5346079","0.5345397","0.5345397","0.5338374","0.53248763","0.532252","0.5320426","0.5319489","0.5317254","0.5316007","0.53157526","0.5315528","0.5314088","0.5276103","0.52592456","0.5252945","0.52516335","0.5237588","0.5234615","0.52290595","0.5226282","0.52133906","0.52133423","0.5208048","0.52067125","0.52059543","0.5203139","0.52028215","0.520153","0.5201512","0.51931256","0.51921076","0.5191898","0.51842654","0.5183282","0.51822114","0.5181543","0.5178827","0.5176814","0.51719433","0.51676685","0.516113","0.5155078","0.51549727","0.51543605","0.5144739","0.51423174","0.5140835","0.51403606","0.5140002","0.5136807","0.5132944","0.5128192","0.5123011","0.5122714","0.51198983","0.51198983"],"string":"[\n \"0.6354442\",\n \"0.6312051\",\n \"0.6045636\",\n \"0.5982405\",\n \"0.5920717\",\n \"0.58340013\",\n \"0.57912403\",\n \"0.5770052\",\n \"0.5703894\",\n \"0.5652854\",\n \"0.5625554\",\n \"0.5597974\",\n \"0.5590781\",\n \"0.5573974\",\n \"0.5573084\",\n \"0.5562036\",\n \"0.55604845\",\n \"0.55475634\",\n \"0.55385345\",\n \"0.552718\",\n \"0.552718\",\n \"0.5526244\",\n \"0.55233794\",\n \"0.5521452\",\n \"0.5500657\",\n \"0.54848874\",\n \"0.54796004\",\n \"0.5433063\",\n \"0.54319966\",\n \"0.5410045\",\n \"0.5409456\",\n \"0.5409456\",\n \"0.5409456\",\n \"0.54083014\",\n \"0.54032725\",\n \"0.5388008\",\n \"0.53760797\",\n \"0.53703284\",\n \"0.5366612\",\n \"0.5365515\",\n \"0.5361175\",\n \"0.5353246\",\n \"0.53477454\",\n \"0.5346079\",\n \"0.5345397\",\n \"0.5345397\",\n \"0.5338374\",\n \"0.53248763\",\n \"0.532252\",\n \"0.5320426\",\n \"0.5319489\",\n \"0.5317254\",\n \"0.5316007\",\n \"0.53157526\",\n \"0.5315528\",\n \"0.5314088\",\n \"0.5276103\",\n \"0.52592456\",\n \"0.5252945\",\n \"0.52516335\",\n \"0.5237588\",\n \"0.5234615\",\n \"0.52290595\",\n \"0.5226282\",\n \"0.52133906\",\n \"0.52133423\",\n \"0.5208048\",\n \"0.52067125\",\n \"0.52059543\",\n \"0.5203139\",\n \"0.52028215\",\n \"0.520153\",\n \"0.5201512\",\n \"0.51931256\",\n \"0.51921076\",\n \"0.5191898\",\n \"0.51842654\",\n \"0.5183282\",\n \"0.51822114\",\n \"0.5181543\",\n \"0.5178827\",\n \"0.5176814\",\n \"0.51719433\",\n \"0.51676685\",\n \"0.516113\",\n \"0.5155078\",\n \"0.51549727\",\n \"0.51543605\",\n \"0.5144739\",\n \"0.51423174\",\n \"0.5140835\",\n \"0.51403606\",\n \"0.5140002\",\n \"0.5136807\",\n \"0.5132944\",\n \"0.5128192\",\n \"0.5123011\",\n \"0.5122714\",\n \"0.51198983\",\n \"0.51198983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5722098"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":9454,"cells":{"query":{"kind":"string","value":"Statistics of operation calls"},"document":{"kind":"string","value":"def operation_calls(self):\n return self._operation_calls"},"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 callstats(): # real signature unknown; restored from __doc__\n return ()","def compute_statistics(self):","def op_callcount(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n rval.setdefault(node.op, 0)\r\n rval[node.op] += count\r\n return rval","def op_callcount(self):\n # timing is stored by node, we compute timing by Op on demand\n rval = {}\n for (fgraph, node), count in self.apply_callcount.items():\n rval.setdefault(node.op, 0)\n rval[node.op] += count\n return rval","def total_ops(self):\n return self._total_ops","def list_operations():","def operation_counts(self) -> Dict[int, Dict[str, int]]:\n return self._operation_counts","def op_nodes(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n rval.setdefault(node.op, 0)\r\n rval[node.op] += 1\r\n return rval","def stats(self):","def getOperationCount():\n return _operationCount","def summarize_operation(self, operation):\n print \"================ \"+ operation +\" ================\"\n sys.stdout.flush()","def class_callcount(self):\r\n # timing is stored by node, we compute timing by class on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n typ = type(node.op)\r\n rval.setdefault(typ, 0)\r\n rval[typ] += count\r\n return rval","def op_nodes(self):\n # timing is stored by node, we compute timing by Op on demand\n rval = {}\n for (fgraph, node), count in self.apply_callcount.items():\n rval.setdefault(node.op, 0)\n rval[node.op] += 1\n return rval","def advancedStats():","def class_callcount(self):\n # timing is stored by node, we compute timing by class on demand\n rval = {}\n for (fgraph, node), count in self.apply_callcount.items():\n typ = type(node.op)\n rval.setdefault(typ, 0)\n rval[typ] += count\n return rval","def count_ops(self, visual=None):\n from .function import count_ops\n return count_ops(self, visual)","def stats(self):\n pass","def test_statistics(self):\n import multiprocessing, os, time\n from supvisors.statistics import instant_statistics, statistics\n named_pid = 'myself', os.getpid()\n ref_stats = instant_statistics([named_pid])\n time.sleep(2)\n last_stats = instant_statistics([named_pid])\n stats = statistics(last_stats, ref_stats)\n # check result\n self.assertEqual(5, len(stats))\n date, cpu_stats, mem_stats, io_stats, proc_stats = stats\n # check date\n self.assertEqual(last_stats[0], date)\n # check cpu\n self.assertEqual(multiprocessing.cpu_count() + 1, len(cpu_stats))\n for cpu in cpu_stats:\n self.assertIs(float, type(cpu))\n self.assertGreaterEqual(cpu, 0)\n self.assertLessEqual(cpu, 100)\n # check memory\n self.assertIs(float, type(mem_stats))\n self.assertEqual(last_stats[2], mem_stats)\n # check io\n for intf, bytes in io_stats.items():\n self.assertIs(str, type(intf))\n self.assertEqual(2, len(bytes))\n for value in bytes:\n self.assertIs(float, type(value))\n # check process stats\n self.assertListEqual([named_pid], proc_stats.keys())\n values = proc_stats[named_pid]\n self.assertEqual(2, len(values))\n for value in values:\n self.assertIs(float, type(value))\n self.assertGreaterEqual(value, 0)\n self.assertLessEqual(value, 100)","def num_ops(self):\n num_ops = len(self.desc.normal.genotype[0][0])\n return num_ops","def get_statistics(self):\n\n return (self.func_id, self.instruction_count)","def get_fused_operator_statistics(self):\n op_count = {}\n ops = [\n \"Attention\",\n \"MultiHeadAttention\",\n \"LayerNormalization\",\n \"SkipLayerNormalization\",\n \"BiasSplitGelu\",\n \"GroupNorm\",\n \"NhwcConv\",\n \"BiasAdd\",\n ]\n for op in ops:\n nodes = self.get_nodes_by_op_type(op)\n op_count[op] = len(nodes)\n\n logger.info(f\"Optimized operators:{op_count}\")\n return op_count","def compute_statistics(connection: DBConnection) -> None:\n for f in STATS_FUNCS.values():\n f(connection)","def calls(self, arg=1):\r\n call_counter()\r\n return arg, call_counter.call_count","def stat(**kwargs):\n print(\"output stats\")","def __call__(self, node, operations, last_operation):\n cost = 0\n # if MOVE_OPERATION in operations or MOVE_OPERATION == last_operation:\n # return NotImplemented\n if NO_OPERATION != last_operation:\n cost += 1\n try:\n if operations[-1] != NO_OPERATION:\n cost += 1\n except IndexError:\n pass\n return cost","def cmd_calculation():","def statistics(self, **_):\n raise NotImplementedError(\"{} doesn't support statistics.\".format(__class__.__name__))","def op_time(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node, t in self.apply_time.items():\r\n rval.setdefault(node.op, 0)\r\n rval[node.op] += t\r\n return rval","def op_time(self):\n # timing is stored by node, we compute timing by Op on demand\n rval = {}\n for (fgraph, node), t in self.apply_time.items():\n rval.setdefault(node.op, 0)\n rval[node.op] += t\n return rval","def operation(self):\n pass","def test_instant_cpu_statistics(self):\n import multiprocessing\n from supvisors.statistics import instant_cpu_statistics\n stats = instant_cpu_statistics()\n # test number of results (number of cores + average)\n self.assertEqual(multiprocessing.cpu_count() + 1, len(stats))\n # test average value\n total_work = total_idle = 0\n for cpu in stats[1:]:\n self.assertEqual(2, len(cpu))\n work, idle = cpu\n total_work += work\n total_idle += idle\n self.assertAlmostEqual(stats[0][0], total_work / multiprocessing.cpu_count())\n self.assertAlmostEqual(stats[0][1], total_idle / multiprocessing.cpu_count())","def test_instant_statistics(self):\n import multiprocessing, os, time\n from supvisors.statistics import instant_statistics\n stats = instant_statistics([('myself', os.getpid())])\n # check result\n self.assertEqual(5, len(stats))\n date, cpu_stats, mem_stats, io_stats, proc_stats = stats\n # check time (current is greater)\n self.assertGreater(time.time(), date)\n # check cpu jiffies\n self.assertEqual(multiprocessing.cpu_count() + 1, len(cpu_stats))\n for cpu in cpu_stats:\n self.assertEqual(2, len(cpu))\n for value in cpu:\n self.assertIs(float, type(value))\n # check memory\n self.assertIs(float, type(mem_stats))\n self.assertGreaterEqual(mem_stats, 0)\n self.assertLessEqual(mem_stats, 100)\n # check io\n for intf, bytes in io_stats.items():\n self.assertIs(str, type(intf))\n self.assertEqual(2, len(bytes))\n for value in bytes:\n self.assertIs(int, type(value))\n # check process stats\n self.assertListEqual(['myself'], proc_stats.keys())\n values = proc_stats['myself']\n self.assertEqual(2, len(values))\n self.assertEqual(os.getpid(), values[0])\n self.assertEqual(2, len(values[1]))\n for value in values[1]:\n self.assertIs(float, type(value))\n self.assertGreaterEqual(value, 0)\n self.assertLessEqual(value, 100)","def stats(self):\n nqbits = self.operator.num_qubits","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def computeStatementOperation(self, trace_collection):","def compute_metrics(self):\n pass","def __call__(self, node, operations, last_operation):\n if last_operation == NO_OPERATION:\n return 0\n return 1","def class_nodes(self):\r\n # timing is stored by node, we compute timing by class on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n typ = type(node.op)\r\n rval.setdefault(typ, 0)\r\n rval[typ] += 1\r\n return rval","def testOperation(self):\n gen = self.gen\n prof = self.profile\n\n # Try the direct evaluation\n gen.operation()\n self.assertTrue(array_equal(prof.x, prof.ycalc))\n\n # Try evaluation through __call__\n gen(prof.x)\n self.assertTrue(array_equal(prof.x, prof.ycalc))\n return","def calculate_output(self):","def cmd_stat(args):","def calc_all_myOperations():\n while len(myOperations)>1:\n f_nb = float(myOperations[0])\n operator = myOperations[1]\n s_nb = float(myOperations[2])\n \n if operator == \"+\": \n result = f_nb + s_nb\n elif operator== \"-\":\n result = f_nb - s_nb\n elif operator== \"*\":\n result = f_nb * s_nb\n elif operator== \"/\":\n result = f_nb / s_nb\n elif operator== \"% of \":\n print(myOperations)\n result = f_nb/100*s_nb\n \n round_result=round(result,5)\n del myOperations[:2]\n myOperations[0]=round_result\n \n clear_myOperations() \n return round_result","def execute(self, *args):\n if self.total_ops > 0:\n ret = super(BulkOperator, self).execute(*args)\n result_counter = {}\n for key in ret:\n if key in ['writeConcernErrors', 'writeErrors']:\n if len(ret[key]) > 0:\n result_counter[key] = len(ret[key])\n sys.stderr.write('{}:\\n\\t{}'.format(key, ret[key]))\n elif key != 'upserted':\n result_counter[key] = ret[key]\n return Counter(result_counter)\n else:\n return {'ops': 'No ops found'}","def compute_debug(self):","def calculate(self):","def dataStats(self):\n print (\"Performing statistical analysis of the data\")\n # stuff to do","def stats(self):\n raise NotImplementedError(\"Must implement in frontend subclass.\")","def visit_papi_operations(json_metadata: JsonObject,\n call_fn: OperationMappingCallFunction,\n initial_accumulator: Accumulator) -> Accumulator:\n\n accumulator = initial_accumulator\n\n def examine_calls(calls: JsonObject, path_so_far: List[AnyStr]) -> None:\n for call_name in calls:\n attempts = calls[call_name]\n for attempt in attempts:\n operation_id = attempt.get('jobId')\n sub_workflow_metadata = attempt.get('subWorkflowMetadata')\n path = build_call_path(call_name, path_so_far, attempt)\n if operation_id:\n call_fn(accumulator, operation_id, path, attempt)\n if sub_workflow_metadata:\n examine_calls(sub_workflow_metadata.get('calls', {}), path)\n\n def build_call_path(call_name: str, path_so_far: List[AnyStr], attempt: dict) -> List[AnyStr]:\n call_path = path_so_far.copy()\n\n # Remove confusing duplication in subworkflow call names.\n # A parent workflow would name a subworkflow call \"parent_wf.sub_wf\".\n # The subworkflow would name its calls \"sub_wf.sub_call\".\n # If those call components were simply joined the result would be\n # \"parent_wf.sub_wf.sub_wf.sub_call\". This logic removes the duplication of \"sub_wf\",\n # resulting in \"parent_wf.sub_wf.sub_call\".\n deduplicated_call_name = call_name\n if len(path_so_far) > 0:\n this_call_components = call_name.split('.')\n if len(this_call_components) > 1 and path_so_far[-1].endswith('.' + this_call_components[0]):\n deduplicated_call_name = '.'.join(this_call_components[1:])\n\n call_path.append(deduplicated_call_name)\n shard_index = attempt.get('shardIndex', -1)\n if shard_index != -1:\n call_path.append(f\"shard_{shard_index:04d}\")\n\n return call_path\n\n examine_calls(calls=json_metadata.get('calls', {}), path_so_far=[])\n\n return accumulator","def time_over_oracle_calls_reduction_metric(model, query_iterator, N, recalls=[1]):\n exp = run_oracle_experiments(model, query_iterator, N, recalls=recalls)\n expect_times, expect_calls, expect_calls_baseline = exp\n expect_calls_reduction = expect_calls_baseline - expect_calls\n \n strictly_positive = 0 < expect_calls_reduction\n safe_div = np.where(strictly_positive, expect_calls_reduction, 1)\n ToCRs = np.where(strictly_positive, expect_times/safe_div, np.inf)\n return ToCRs","def logging(self, function):\n avg_nms_time_per_step = sum(self.nms_times)/len(self.nms_times)\n avg_total_time_per_step = sum(self.total_times)/len(self.total_times)\n\n avg_min_latency = [x[0] for x in self.inference_times]\n avg_max_latency = [x[1] for x in self.inference_times]\n avg_latency = [x[2] for x in self.inference_times]\n\n function(\"Inference stats: image size {}x{}, batches per step {}, batch size {}, {} steps\".format(\n self.cfg.model.image_size, self.cfg.model.image_size, self.cfg.ipuopts.batches_per_step, self.cfg.model.micro_batch_size, len(self.total_times)\n ))\n function(\"--------------------------------------------------\")\n function(\"Inference\")\n function(\"Average Min Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_min_latency)/len(self.inference_times)))\n function(\"Average Max Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_max_latency)/len(self.inference_times)))\n function(\"Average Latency per Batch: {:.3f} ms\".format(1000 * sum(avg_latency)/len(self.inference_times)))\n function(\"Average Inference Throughput: {:.3f} img/s\".format(sum(self.inference_throughputs)/len(self.inference_throughputs)))\n function(\"--------------------------------------------------\")\n # TODO remove the NMS and end-to-end time report once NMS is on device\n function(\"End-to-end\")\n function(\"Average NMS Latency per Batch: {:.3f} ms\".format(1000 * avg_nms_time_per_step/self.cfg.ipuopts.batches_per_step))\n function(\"Average End-to-end Latency per Batch: {:.3f} ms\".format(1000 * avg_total_time_per_step/self.cfg.ipuopts.batches_per_step))\n function(\"End-to-end Throughput: {:.3f} img/s\".format(sum(self.total_throughputs)/len(self.total_throughputs)))\n function(\"==================================================\")\n\n if self.cfg.eval.metrics:\n self.compute_and_print_eval_metrics()","def print_func_measuremetns():\n print(\"Measured functions:\")\n for func in measured_funcs:\n fn = func.func_name\n tr = func.total_runtime\n tc = func.total_calls\n tpc = 'N/A' if tc == 0 else \"{:10.10f}\".format(tr / tc)\n line = \"{:>30}: {:10.8f}s over {:10d} calls ({} per call)\".format(fn, tr, tc, tpc)\n print(line)","def count_benchmarks():\n return len(setup_storage().fetch_benchmark({}))","def _compute_statistics(self):\n # log to file\n output_dir = self.params['output_dir']\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n output_dir = os.path.join(output_dir, 'statistics.log')\n log = logging.getLogger('tensorflow')\n handle = logging.FileHandler(output_dir)\n log.addHandler(handle)\n\n # FLOPS\n encoder_flops, decoder_flops = 0, 0\n encoder_count, decoder_count = 0, 0\n graph = tf.get_default_graph()\n for operation in graph.get_operations():\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\n 'flops').value\n if flops is None:\n continue\n if operation.name.startswith('model/encoder'):\n # encoder\n encoder_flops += flops\n encoder_count += 1\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\n elif operation.name.startswith('model/decoder'):\n # decoder\n decoder_flops += flops\n decoder_count += 1\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\n else:\n # gradient\n pass\n tf.logging.info('flops of %d encoder tensor: %d',\n encoder_count, encoder_flops)\n tf.logging.info('flops of %d decoder tensor: %d',\n decoder_count, decoder_flops)\n tf.logging.info('flops of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_flops + decoder_flops)\n # parameters\n encoder_parameters, decoder_parameters = 0, 0\n encoder_count, decoder_count = 0, 0\n for var in tf.trainable_variables():\n parameters = np.prod(var.get_shape().as_list())\n if var.name.startswith('model/encoder'):\n # encoder\n encoder_parameters += parameters\n encoder_count += 1\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\n elif var.name.startswith('model/decoder'):\n # decoder\n decoder_parameters += parameters\n decoder_count += 1\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\n\n tf.logging.info('parameters of %d encoder tensor: %d',\n encoder_count, encoder_parameters)\n tf.logging.info('parameters of %d decoder tensor: %d',\n decoder_count, decoder_parameters)\n tf.logging.info('parameters of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_parameters + decoder_parameters)\n # disable log to file\n log.removeHandler(handle)","def commands_complexity():\n complexity()","def compute_stats(self):\n from vmc.common.oal import osobj\n d = osobj.get_iface_stats()\n d.addCallback(self.update_stats)","def num_calls_total(self):\n return self._num_calls_total","def report_total_usage(self):\n work_time = 0\n if self.type == 'normal':\n work_time = self.fwk.fwk_global_time - self.start_exec_time\n elif self.type == 'sandia_work':\n self.total_time += self.fwk.fwk_global_time - self.start_exec_time\n self.total_usage = self.total_time * self.nproc\n if self.state == \"running\":\n # update total work done\n self.sim.completed_work += self.fwk.fwk_global_time - self.start_exec_time\n elif self.state == \"failed\":\n # add this work to the work to be redone\n self.sim.rework_todo += self.fwk.fwk_global_time - self.start_exec_time\n self.state = \"not_ready\"\n self.num_faults += 1\n elif self.type == 'sandia_rework':\n self.total_rework_time += self.fwk.fwk_global_time - self.start_exec_time\n self.total_rework_usage = self.total_rework_time * self.nproc\n if self.state == \"running\":\n # update total work done\n self.sim.next_ckpt = self.sim.ckpt_interval - (self.fwk.fwk_global_time - self.start_exec_time)\n self.sim.rework_todo -= self.fwk.fwk_global_time - self.start_exec_time\n elif self.state == \"failed\":\n # add this work to the work to be redone\n self.state = \"not_ready\"\n self.num_faults += 1\n elif self.type == 'sandia_ckpt':\n self.total_ckpt_time += self.fwk.fwk_global_time - self.start_exec_time\n self.total_ckpt_usage = self.total_ckpt_time * self.nproc\n if self.state == \"running\":\n # update last ckpt\n self.sim.last_ckpt = self.sim.completed_work\n elif self.state == \"failed\":\n # add work to rework\n self.sim.rework_todo += self.sim.next_ckpt\n self.state = \"not_ready\"\n self.num_faults += 1\n elif self.type == 'sandia_restart':\n print(\"time spent in rework\", self.fwk.fwk_global_time - self.start_exec_time)\n self.total_restart_time += self.fwk.fwk_global_time - self.start_exec_time\n self.total_restart_usage = self.total_restart_time * self.nproc\n #if self.state == \"running\":\n # nothing to do?\n # pass\n if self.state == \"failed\":\n # gotta try again\n self.state = \"ready\"\n self.num_faults += 1\n else:\n print(\"problems updating state in report_total_usage\")\n raise\n if self.type == 'normal':\n if self.sim.state == 'rework':\n self.total_rework_time += work_time\n self.total_rework_usage = self.total_rework_time * self.nproc\n else: # sim.state == 'work'\n if self.retry:\n self.total_rework_time += work_time\n self.total_rework_usage = self.total_rework_time * self.nproc\n else:\n self.total_time += work_time\n self.total_usage = self.total_time * self.nproc","def calculate_batch_metrics(self):\n pass","def test_get_stats(self):\n pass","def calculate(self):\r\n\r\n pass","def test_success_metrics(self):\n @self.graph.route(self.ns.collection_path, Operation.Search, self.ns)\n def foo():\n return \"\"\n\n response = self.client.get(\"api/v1/foo\")\n assert_that(response.status_code, is_(equal_to(200)))\n\n self.graph.metrics.histogram.assert_called_with(\n \"route\",\n ANY,\n tags=[\n \"endpoint:foo.search.v1\",\n \"backend_type:microcosm_flask\",\n ],\n )\n self.graph.metrics.increment.assert_called_with(\n \"route.call.count\",\n tags=[\n \"endpoint:foo.search.v1\",\n \"backend_type:microcosm_flask\",\n \"classifier:2xx\",\n ],\n )","def _compute_experiment_statistics(self):\n pass","def calculate(self):\r\n pass","def stats(self, ops=(min, max, np.median, sum)):\n names = [op.__name__ for op in ops]\n ops = [_zero_on_type_error(op) for op in ops]\n columns = [[op(column) for op in ops] for column in self.columns]\n table = self._with_columns(columns)\n stats = table._unused_label('statistic')\n table[stats] = names\n table.move_to_start(stats)\n return table","def second_method(self, total: int, operation: str):\n\n print(f'Total: {total}')\n print(f'Operations: {operation}')","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","def measure(funcs, args, comment='', verbose=False, number=1):\n if not comment:\n comment = repr(args)\n\n # measure performance\n results = []\n w = max(len(name) for name, _ in funcs)\n for name, f in funcs:\n results.append((measure_func(f, args, number=number), name))\n if verbose:\n print(\"{:{}s} {:>9s} {}\".format(\n name, w, human_seconds(results[-1][0]), comment))\n\n # print sorted results\n results.sort()\n mint = results[0][0] # minimal time\n ratios = [\"%5.2f\" % (t / mint,) for t, _ in results]\n maxratio_width = max(len(r) for r in ratios)\n # header\n print(\"{:{}s} {:>9s} {:>{}s} {}\".format(\n \"name\", w, \"time\", \"ratio\", maxratio_width, \"comment\"))\n ratios = [s.rjust(maxratio_width) for s in ratios]\n for (t, name), ratio in zip(results, ratios):\n print(\"{:{}s} {:>9s} {} {}\".format(\n name, w, human_seconds(t), ratio, comment))\n return results","def __init__(self):\r\n self.num_calls = 0","def print_usage(self):\r\n print 'Total Usage: %f compute seconds' % self.box_usage\r\n cost = self.box_usage * 0.14\r\n print 'Approximate Cost: $%f' % cost","def sum_stats(input_stats, out, name):\n ss(input_stats, out, name)","def class_nodes(self):\n # timing is stored by node, we compute timing by class on demand\n rval = {}\n for (fgraph, node), count in self.apply_callcount.items():\n typ = type(node.op)\n rval.setdefault(typ, 0)\n rval[typ] += 1\n return rval","def test_fn_called():\n l = [1, 2, 3, 4, 5]\n for fn in [s7.div, s7.mul, s7.add, \"abcd\", 1234]:\n try:\n f = s7.count_fn_called(fn=fn)\n for i in range(0, random.randint(2, 10)):\n f(*l)\n assert fn in s7.fn_called_dict.keys() and str(s7.fn_called_dict[fn]) in s7.check_all_fn_called(fn)\n except Exception as e:\n assert e.__class__.__name__ == TypeError.__name__","def op_impl(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node in self.apply_callcount:\r\n if self.apply_cimpl[node]:\r\n rval[node.op] = 'C '\r\n else:\r\n rval[node.op] = 'Py'\r\n return rval","def test_get_batch_statistics_request(self):\n self.trans_details.get_batch_statistics(\n batch_id = 123456,\n )","def calculate(self):\n pass","def completed_operations(self) -> int:\n return self._completed_operations.value()","def test_total_throughput(self):\n self.query(\n \"CREATE TABLE foobar \"\n \"(id STRING HASH KEY, foo NUMBER, THROUGHPUT (1, 1))\"\n \"GLOBAL INDEX ('idx', id, foo, THROUGHPUT(1, 1))\"\n )\n desc = self.engine.describe(\"foobar\", refresh=True)\n self.assertEqual(desc.total_read_throughput, 2)\n self.assertEqual(desc.total_write_throughput, 2)","def measure(self):\n pass","def calculateRunTime(function, *args):\n startTime = time.time()\n result = function(*args)\n return time.time() - startTime, result","def print_usage(self):\n print('Total Usage: %f compute seconds' % self.box_usage)\n cost = self.box_usage * 0.14\n print('Approximate Cost: $%f' % cost)","def stats(self):\n return self.rpc.call(MsfRpcMethod.CoreModuleStats)","def reduce_run():","def statistics(self):\n raise NotImplemented()"],"string":"[\n \"def callstats(): # real signature unknown; restored from __doc__\\n return ()\",\n \"def compute_statistics(self):\",\n \"def op_callcount(self):\\r\\n # timing is stored by node, we compute timing by Op on demand\\r\\n rval = {}\\r\\n for node, count in self.apply_callcount.items():\\r\\n rval.setdefault(node.op, 0)\\r\\n rval[node.op] += count\\r\\n return rval\",\n \"def op_callcount(self):\\n # timing is stored by node, we compute timing by Op on demand\\n rval = {}\\n for (fgraph, node), count in self.apply_callcount.items():\\n rval.setdefault(node.op, 0)\\n rval[node.op] += count\\n return rval\",\n \"def total_ops(self):\\n return self._total_ops\",\n \"def list_operations():\",\n \"def operation_counts(self) -> Dict[int, Dict[str, int]]:\\n return self._operation_counts\",\n \"def op_nodes(self):\\r\\n # timing is stored by node, we compute timing by Op on demand\\r\\n rval = {}\\r\\n for node, count in self.apply_callcount.items():\\r\\n rval.setdefault(node.op, 0)\\r\\n rval[node.op] += 1\\r\\n return rval\",\n \"def stats(self):\",\n \"def getOperationCount():\\n return _operationCount\",\n \"def summarize_operation(self, operation):\\n print \\\"================ \\\"+ operation +\\\" ================\\\"\\n sys.stdout.flush()\",\n \"def class_callcount(self):\\r\\n # timing is stored by node, we compute timing by class on demand\\r\\n rval = {}\\r\\n for node, count in self.apply_callcount.items():\\r\\n typ = type(node.op)\\r\\n rval.setdefault(typ, 0)\\r\\n rval[typ] += count\\r\\n return rval\",\n \"def op_nodes(self):\\n # timing is stored by node, we compute timing by Op on demand\\n rval = {}\\n for (fgraph, node), count in self.apply_callcount.items():\\n rval.setdefault(node.op, 0)\\n rval[node.op] += 1\\n return rval\",\n \"def advancedStats():\",\n \"def class_callcount(self):\\n # timing is stored by node, we compute timing by class on demand\\n rval = {}\\n for (fgraph, node), count in self.apply_callcount.items():\\n typ = type(node.op)\\n rval.setdefault(typ, 0)\\n rval[typ] += count\\n return rval\",\n \"def count_ops(self, visual=None):\\n from .function import count_ops\\n return count_ops(self, visual)\",\n \"def stats(self):\\n pass\",\n \"def test_statistics(self):\\n import multiprocessing, os, time\\n from supvisors.statistics import instant_statistics, statistics\\n named_pid = 'myself', os.getpid()\\n ref_stats = instant_statistics([named_pid])\\n time.sleep(2)\\n last_stats = instant_statistics([named_pid])\\n stats = statistics(last_stats, ref_stats)\\n # check result\\n self.assertEqual(5, len(stats))\\n date, cpu_stats, mem_stats, io_stats, proc_stats = stats\\n # check date\\n self.assertEqual(last_stats[0], date)\\n # check cpu\\n self.assertEqual(multiprocessing.cpu_count() + 1, len(cpu_stats))\\n for cpu in cpu_stats:\\n self.assertIs(float, type(cpu))\\n self.assertGreaterEqual(cpu, 0)\\n self.assertLessEqual(cpu, 100)\\n # check memory\\n self.assertIs(float, type(mem_stats))\\n self.assertEqual(last_stats[2], mem_stats)\\n # check io\\n for intf, bytes in io_stats.items():\\n self.assertIs(str, type(intf))\\n self.assertEqual(2, len(bytes))\\n for value in bytes:\\n self.assertIs(float, type(value))\\n # check process stats\\n self.assertListEqual([named_pid], proc_stats.keys())\\n values = proc_stats[named_pid]\\n self.assertEqual(2, len(values))\\n for value in values:\\n self.assertIs(float, type(value))\\n self.assertGreaterEqual(value, 0)\\n self.assertLessEqual(value, 100)\",\n \"def num_ops(self):\\n num_ops = len(self.desc.normal.genotype[0][0])\\n return num_ops\",\n \"def get_statistics(self):\\n\\n return (self.func_id, self.instruction_count)\",\n \"def get_fused_operator_statistics(self):\\n op_count = {}\\n ops = [\\n \\\"Attention\\\",\\n \\\"MultiHeadAttention\\\",\\n \\\"LayerNormalization\\\",\\n \\\"SkipLayerNormalization\\\",\\n \\\"BiasSplitGelu\\\",\\n \\\"GroupNorm\\\",\\n \\\"NhwcConv\\\",\\n \\\"BiasAdd\\\",\\n ]\\n for op in ops:\\n nodes = self.get_nodes_by_op_type(op)\\n op_count[op] = len(nodes)\\n\\n logger.info(f\\\"Optimized operators:{op_count}\\\")\\n return op_count\",\n \"def compute_statistics(connection: DBConnection) -> None:\\n for f in STATS_FUNCS.values():\\n f(connection)\",\n \"def calls(self, arg=1):\\r\\n call_counter()\\r\\n return arg, call_counter.call_count\",\n \"def stat(**kwargs):\\n print(\\\"output stats\\\")\",\n \"def __call__(self, node, operations, last_operation):\\n cost = 0\\n # if MOVE_OPERATION in operations or MOVE_OPERATION == last_operation:\\n # return NotImplemented\\n if NO_OPERATION != last_operation:\\n cost += 1\\n try:\\n if operations[-1] != NO_OPERATION:\\n cost += 1\\n except IndexError:\\n pass\\n return cost\",\n \"def cmd_calculation():\",\n \"def statistics(self, **_):\\n raise NotImplementedError(\\\"{} doesn't support statistics.\\\".format(__class__.__name__))\",\n \"def op_time(self):\\r\\n # timing is stored by node, we compute timing by Op on demand\\r\\n rval = {}\\r\\n for node, t in self.apply_time.items():\\r\\n rval.setdefault(node.op, 0)\\r\\n rval[node.op] += t\\r\\n return rval\",\n \"def op_time(self):\\n # timing is stored by node, we compute timing by Op on demand\\n rval = {}\\n for (fgraph, node), t in self.apply_time.items():\\n rval.setdefault(node.op, 0)\\n rval[node.op] += t\\n return rval\",\n \"def operation(self):\\n pass\",\n \"def test_instant_cpu_statistics(self):\\n import multiprocessing\\n from supvisors.statistics import instant_cpu_statistics\\n stats = instant_cpu_statistics()\\n # test number of results (number of cores + average)\\n self.assertEqual(multiprocessing.cpu_count() + 1, len(stats))\\n # test average value\\n total_work = total_idle = 0\\n for cpu in stats[1:]:\\n self.assertEqual(2, len(cpu))\\n work, idle = cpu\\n total_work += work\\n total_idle += idle\\n self.assertAlmostEqual(stats[0][0], total_work / multiprocessing.cpu_count())\\n self.assertAlmostEqual(stats[0][1], total_idle / multiprocessing.cpu_count())\",\n \"def test_instant_statistics(self):\\n import multiprocessing, os, time\\n from supvisors.statistics import instant_statistics\\n stats = instant_statistics([('myself', os.getpid())])\\n # check result\\n self.assertEqual(5, len(stats))\\n date, cpu_stats, mem_stats, io_stats, proc_stats = stats\\n # check time (current is greater)\\n self.assertGreater(time.time(), date)\\n # check cpu jiffies\\n self.assertEqual(multiprocessing.cpu_count() + 1, len(cpu_stats))\\n for cpu in cpu_stats:\\n self.assertEqual(2, len(cpu))\\n for value in cpu:\\n self.assertIs(float, type(value))\\n # check memory\\n self.assertIs(float, type(mem_stats))\\n self.assertGreaterEqual(mem_stats, 0)\\n self.assertLessEqual(mem_stats, 100)\\n # check io\\n for intf, bytes in io_stats.items():\\n self.assertIs(str, type(intf))\\n self.assertEqual(2, len(bytes))\\n for value in bytes:\\n self.assertIs(int, type(value))\\n # check process stats\\n self.assertListEqual(['myself'], proc_stats.keys())\\n values = proc_stats['myself']\\n self.assertEqual(2, len(values))\\n self.assertEqual(os.getpid(), values[0])\\n self.assertEqual(2, len(values[1]))\\n for value in values[1]:\\n self.assertIs(float, type(value))\\n self.assertGreaterEqual(value, 0)\\n self.assertLessEqual(value, 100)\",\n \"def stats(self):\\n nqbits = self.operator.num_qubits\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def computeStatementOperation(self, trace_collection):\",\n \"def compute_metrics(self):\\n pass\",\n \"def __call__(self, node, operations, last_operation):\\n if last_operation == NO_OPERATION:\\n return 0\\n return 1\",\n \"def class_nodes(self):\\r\\n # timing is stored by node, we compute timing by class on demand\\r\\n rval = {}\\r\\n for node, count in self.apply_callcount.items():\\r\\n typ = type(node.op)\\r\\n rval.setdefault(typ, 0)\\r\\n rval[typ] += 1\\r\\n return rval\",\n \"def testOperation(self):\\n gen = self.gen\\n prof = self.profile\\n\\n # Try the direct evaluation\\n gen.operation()\\n self.assertTrue(array_equal(prof.x, prof.ycalc))\\n\\n # Try evaluation through __call__\\n gen(prof.x)\\n self.assertTrue(array_equal(prof.x, prof.ycalc))\\n return\",\n \"def calculate_output(self):\",\n \"def cmd_stat(args):\",\n \"def calc_all_myOperations():\\n while len(myOperations)>1:\\n f_nb = float(myOperations[0])\\n operator = myOperations[1]\\n s_nb = float(myOperations[2])\\n \\n if operator == \\\"+\\\": \\n result = f_nb + s_nb\\n elif operator== \\\"-\\\":\\n result = f_nb - s_nb\\n elif operator== \\\"*\\\":\\n result = f_nb * s_nb\\n elif operator== \\\"/\\\":\\n result = f_nb / s_nb\\n elif operator== \\\"% of \\\":\\n print(myOperations)\\n result = f_nb/100*s_nb\\n \\n round_result=round(result,5)\\n del myOperations[:2]\\n myOperations[0]=round_result\\n \\n clear_myOperations() \\n return round_result\",\n \"def execute(self, *args):\\n if self.total_ops > 0:\\n ret = super(BulkOperator, self).execute(*args)\\n result_counter = {}\\n for key in ret:\\n if key in ['writeConcernErrors', 'writeErrors']:\\n if len(ret[key]) > 0:\\n result_counter[key] = len(ret[key])\\n sys.stderr.write('{}:\\\\n\\\\t{}'.format(key, ret[key]))\\n elif key != 'upserted':\\n result_counter[key] = ret[key]\\n return Counter(result_counter)\\n else:\\n return {'ops': 'No ops found'}\",\n \"def compute_debug(self):\",\n \"def calculate(self):\",\n \"def dataStats(self):\\n print (\\\"Performing statistical analysis of the data\\\")\\n # stuff to do\",\n \"def stats(self):\\n raise NotImplementedError(\\\"Must implement in frontend subclass.\\\")\",\n \"def visit_papi_operations(json_metadata: JsonObject,\\n call_fn: OperationMappingCallFunction,\\n initial_accumulator: Accumulator) -> Accumulator:\\n\\n accumulator = initial_accumulator\\n\\n def examine_calls(calls: JsonObject, path_so_far: List[AnyStr]) -> None:\\n for call_name in calls:\\n attempts = calls[call_name]\\n for attempt in attempts:\\n operation_id = attempt.get('jobId')\\n sub_workflow_metadata = attempt.get('subWorkflowMetadata')\\n path = build_call_path(call_name, path_so_far, attempt)\\n if operation_id:\\n call_fn(accumulator, operation_id, path, attempt)\\n if sub_workflow_metadata:\\n examine_calls(sub_workflow_metadata.get('calls', {}), path)\\n\\n def build_call_path(call_name: str, path_so_far: List[AnyStr], attempt: dict) -> List[AnyStr]:\\n call_path = path_so_far.copy()\\n\\n # Remove confusing duplication in subworkflow call names.\\n # A parent workflow would name a subworkflow call \\\"parent_wf.sub_wf\\\".\\n # The subworkflow would name its calls \\\"sub_wf.sub_call\\\".\\n # If those call components were simply joined the result would be\\n # \\\"parent_wf.sub_wf.sub_wf.sub_call\\\". This logic removes the duplication of \\\"sub_wf\\\",\\n # resulting in \\\"parent_wf.sub_wf.sub_call\\\".\\n deduplicated_call_name = call_name\\n if len(path_so_far) > 0:\\n this_call_components = call_name.split('.')\\n if len(this_call_components) > 1 and path_so_far[-1].endswith('.' + this_call_components[0]):\\n deduplicated_call_name = '.'.join(this_call_components[1:])\\n\\n call_path.append(deduplicated_call_name)\\n shard_index = attempt.get('shardIndex', -1)\\n if shard_index != -1:\\n call_path.append(f\\\"shard_{shard_index:04d}\\\")\\n\\n return call_path\\n\\n examine_calls(calls=json_metadata.get('calls', {}), path_so_far=[])\\n\\n return accumulator\",\n \"def time_over_oracle_calls_reduction_metric(model, query_iterator, N, recalls=[1]):\\n exp = run_oracle_experiments(model, query_iterator, N, recalls=recalls)\\n expect_times, expect_calls, expect_calls_baseline = exp\\n expect_calls_reduction = expect_calls_baseline - expect_calls\\n \\n strictly_positive = 0 < expect_calls_reduction\\n safe_div = np.where(strictly_positive, expect_calls_reduction, 1)\\n ToCRs = np.where(strictly_positive, expect_times/safe_div, np.inf)\\n return ToCRs\",\n \"def logging(self, function):\\n avg_nms_time_per_step = sum(self.nms_times)/len(self.nms_times)\\n avg_total_time_per_step = sum(self.total_times)/len(self.total_times)\\n\\n avg_min_latency = [x[0] for x in self.inference_times]\\n avg_max_latency = [x[1] for x in self.inference_times]\\n avg_latency = [x[2] for x in self.inference_times]\\n\\n function(\\\"Inference stats: image size {}x{}, batches per step {}, batch size {}, {} steps\\\".format(\\n self.cfg.model.image_size, self.cfg.model.image_size, self.cfg.ipuopts.batches_per_step, self.cfg.model.micro_batch_size, len(self.total_times)\\n ))\\n function(\\\"--------------------------------------------------\\\")\\n function(\\\"Inference\\\")\\n function(\\\"Average Min Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_min_latency)/len(self.inference_times)))\\n function(\\\"Average Max Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_max_latency)/len(self.inference_times)))\\n function(\\\"Average Latency per Batch: {:.3f} ms\\\".format(1000 * sum(avg_latency)/len(self.inference_times)))\\n function(\\\"Average Inference Throughput: {:.3f} img/s\\\".format(sum(self.inference_throughputs)/len(self.inference_throughputs)))\\n function(\\\"--------------------------------------------------\\\")\\n # TODO remove the NMS and end-to-end time report once NMS is on device\\n function(\\\"End-to-end\\\")\\n function(\\\"Average NMS Latency per Batch: {:.3f} ms\\\".format(1000 * avg_nms_time_per_step/self.cfg.ipuopts.batches_per_step))\\n function(\\\"Average End-to-end Latency per Batch: {:.3f} ms\\\".format(1000 * avg_total_time_per_step/self.cfg.ipuopts.batches_per_step))\\n function(\\\"End-to-end Throughput: {:.3f} img/s\\\".format(sum(self.total_throughputs)/len(self.total_throughputs)))\\n function(\\\"==================================================\\\")\\n\\n if self.cfg.eval.metrics:\\n self.compute_and_print_eval_metrics()\",\n \"def print_func_measuremetns():\\n print(\\\"Measured functions:\\\")\\n for func in measured_funcs:\\n fn = func.func_name\\n tr = func.total_runtime\\n tc = func.total_calls\\n tpc = 'N/A' if tc == 0 else \\\"{:10.10f}\\\".format(tr / tc)\\n line = \\\"{:>30}: {:10.8f}s over {:10d} calls ({} per call)\\\".format(fn, tr, tc, tpc)\\n print(line)\",\n \"def count_benchmarks():\\n return len(setup_storage().fetch_benchmark({}))\",\n \"def _compute_statistics(self):\\n # log to file\\n output_dir = self.params['output_dir']\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n output_dir = os.path.join(output_dir, 'statistics.log')\\n log = logging.getLogger('tensorflow')\\n handle = logging.FileHandler(output_dir)\\n log.addHandler(handle)\\n\\n # FLOPS\\n encoder_flops, decoder_flops = 0, 0\\n encoder_count, decoder_count = 0, 0\\n graph = tf.get_default_graph()\\n for operation in graph.get_operations():\\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\\n 'flops').value\\n if flops is None:\\n continue\\n if operation.name.startswith('model/encoder'):\\n # encoder\\n encoder_flops += flops\\n encoder_count += 1\\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\\n elif operation.name.startswith('model/decoder'):\\n # decoder\\n decoder_flops += flops\\n decoder_count += 1\\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\\n else:\\n # gradient\\n pass\\n tf.logging.info('flops of %d encoder tensor: %d',\\n encoder_count, encoder_flops)\\n tf.logging.info('flops of %d decoder tensor: %d',\\n decoder_count, decoder_flops)\\n tf.logging.info('flops of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_flops + decoder_flops)\\n # parameters\\n encoder_parameters, decoder_parameters = 0, 0\\n encoder_count, decoder_count = 0, 0\\n for var in tf.trainable_variables():\\n parameters = np.prod(var.get_shape().as_list())\\n if var.name.startswith('model/encoder'):\\n # encoder\\n encoder_parameters += parameters\\n encoder_count += 1\\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\\n elif var.name.startswith('model/decoder'):\\n # decoder\\n decoder_parameters += parameters\\n decoder_count += 1\\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\\n\\n tf.logging.info('parameters of %d encoder tensor: %d',\\n encoder_count, encoder_parameters)\\n tf.logging.info('parameters of %d decoder tensor: %d',\\n decoder_count, decoder_parameters)\\n tf.logging.info('parameters of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_parameters + decoder_parameters)\\n # disable log to file\\n log.removeHandler(handle)\",\n \"def commands_complexity():\\n complexity()\",\n \"def compute_stats(self):\\n from vmc.common.oal import osobj\\n d = osobj.get_iface_stats()\\n d.addCallback(self.update_stats)\",\n \"def num_calls_total(self):\\n return self._num_calls_total\",\n \"def report_total_usage(self):\\n work_time = 0\\n if self.type == 'normal':\\n work_time = self.fwk.fwk_global_time - self.start_exec_time\\n elif self.type == 'sandia_work':\\n self.total_time += self.fwk.fwk_global_time - self.start_exec_time\\n self.total_usage = self.total_time * self.nproc\\n if self.state == \\\"running\\\":\\n # update total work done\\n self.sim.completed_work += self.fwk.fwk_global_time - self.start_exec_time\\n elif self.state == \\\"failed\\\":\\n # add this work to the work to be redone\\n self.sim.rework_todo += self.fwk.fwk_global_time - self.start_exec_time\\n self.state = \\\"not_ready\\\"\\n self.num_faults += 1\\n elif self.type == 'sandia_rework':\\n self.total_rework_time += self.fwk.fwk_global_time - self.start_exec_time\\n self.total_rework_usage = self.total_rework_time * self.nproc\\n if self.state == \\\"running\\\":\\n # update total work done\\n self.sim.next_ckpt = self.sim.ckpt_interval - (self.fwk.fwk_global_time - self.start_exec_time)\\n self.sim.rework_todo -= self.fwk.fwk_global_time - self.start_exec_time\\n elif self.state == \\\"failed\\\":\\n # add this work to the work to be redone\\n self.state = \\\"not_ready\\\"\\n self.num_faults += 1\\n elif self.type == 'sandia_ckpt':\\n self.total_ckpt_time += self.fwk.fwk_global_time - self.start_exec_time\\n self.total_ckpt_usage = self.total_ckpt_time * self.nproc\\n if self.state == \\\"running\\\":\\n # update last ckpt\\n self.sim.last_ckpt = self.sim.completed_work\\n elif self.state == \\\"failed\\\":\\n # add work to rework\\n self.sim.rework_todo += self.sim.next_ckpt\\n self.state = \\\"not_ready\\\"\\n self.num_faults += 1\\n elif self.type == 'sandia_restart':\\n print(\\\"time spent in rework\\\", self.fwk.fwk_global_time - self.start_exec_time)\\n self.total_restart_time += self.fwk.fwk_global_time - self.start_exec_time\\n self.total_restart_usage = self.total_restart_time * self.nproc\\n #if self.state == \\\"running\\\":\\n # nothing to do?\\n # pass\\n if self.state == \\\"failed\\\":\\n # gotta try again\\n self.state = \\\"ready\\\"\\n self.num_faults += 1\\n else:\\n print(\\\"problems updating state in report_total_usage\\\")\\n raise\\n if self.type == 'normal':\\n if self.sim.state == 'rework':\\n self.total_rework_time += work_time\\n self.total_rework_usage = self.total_rework_time * self.nproc\\n else: # sim.state == 'work'\\n if self.retry:\\n self.total_rework_time += work_time\\n self.total_rework_usage = self.total_rework_time * self.nproc\\n else:\\n self.total_time += work_time\\n self.total_usage = self.total_time * self.nproc\",\n \"def calculate_batch_metrics(self):\\n pass\",\n \"def test_get_stats(self):\\n pass\",\n \"def calculate(self):\\r\\n\\r\\n pass\",\n \"def test_success_metrics(self):\\n @self.graph.route(self.ns.collection_path, Operation.Search, self.ns)\\n def foo():\\n return \\\"\\\"\\n\\n response = self.client.get(\\\"api/v1/foo\\\")\\n assert_that(response.status_code, is_(equal_to(200)))\\n\\n self.graph.metrics.histogram.assert_called_with(\\n \\\"route\\\",\\n ANY,\\n tags=[\\n \\\"endpoint:foo.search.v1\\\",\\n \\\"backend_type:microcosm_flask\\\",\\n ],\\n )\\n self.graph.metrics.increment.assert_called_with(\\n \\\"route.call.count\\\",\\n tags=[\\n \\\"endpoint:foo.search.v1\\\",\\n \\\"backend_type:microcosm_flask\\\",\\n \\\"classifier:2xx\\\",\\n ],\\n )\",\n \"def _compute_experiment_statistics(self):\\n pass\",\n \"def calculate(self):\\r\\n pass\",\n \"def stats(self, ops=(min, max, np.median, sum)):\\n names = [op.__name__ for op in ops]\\n ops = [_zero_on_type_error(op) for op in ops]\\n columns = [[op(column) for op in ops] for column in self.columns]\\n table = self._with_columns(columns)\\n stats = table._unused_label('statistic')\\n table[stats] = names\\n table.move_to_start(stats)\\n return table\",\n \"def second_method(self, total: int, operation: str):\\n\\n print(f'Total: {total}')\\n print(f'Operations: {operation}')\",\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 measure(funcs, args, comment='', verbose=False, number=1):\\n if not comment:\\n comment = repr(args)\\n\\n # measure performance\\n results = []\\n w = max(len(name) for name, _ in funcs)\\n for name, f in funcs:\\n results.append((measure_func(f, args, number=number), name))\\n if verbose:\\n print(\\\"{:{}s} {:>9s} {}\\\".format(\\n name, w, human_seconds(results[-1][0]), comment))\\n\\n # print sorted results\\n results.sort()\\n mint = results[0][0] # minimal time\\n ratios = [\\\"%5.2f\\\" % (t / mint,) for t, _ in results]\\n maxratio_width = max(len(r) for r in ratios)\\n # header\\n print(\\\"{:{}s} {:>9s} {:>{}s} {}\\\".format(\\n \\\"name\\\", w, \\\"time\\\", \\\"ratio\\\", maxratio_width, \\\"comment\\\"))\\n ratios = [s.rjust(maxratio_width) for s in ratios]\\n for (t, name), ratio in zip(results, ratios):\\n print(\\\"{:{}s} {:>9s} {} {}\\\".format(\\n name, w, human_seconds(t), ratio, comment))\\n return results\",\n \"def __init__(self):\\r\\n self.num_calls = 0\",\n \"def print_usage(self):\\r\\n print 'Total Usage: %f compute seconds' % self.box_usage\\r\\n cost = self.box_usage * 0.14\\r\\n print 'Approximate Cost: $%f' % cost\",\n \"def sum_stats(input_stats, out, name):\\n ss(input_stats, out, name)\",\n \"def class_nodes(self):\\n # timing is stored by node, we compute timing by class on demand\\n rval = {}\\n for (fgraph, node), count in self.apply_callcount.items():\\n typ = type(node.op)\\n rval.setdefault(typ, 0)\\n rval[typ] += 1\\n return rval\",\n \"def test_fn_called():\\n l = [1, 2, 3, 4, 5]\\n for fn in [s7.div, s7.mul, s7.add, \\\"abcd\\\", 1234]:\\n try:\\n f = s7.count_fn_called(fn=fn)\\n for i in range(0, random.randint(2, 10)):\\n f(*l)\\n assert fn in s7.fn_called_dict.keys() and str(s7.fn_called_dict[fn]) in s7.check_all_fn_called(fn)\\n except Exception as e:\\n assert e.__class__.__name__ == TypeError.__name__\",\n \"def op_impl(self):\\r\\n # timing is stored by node, we compute timing by Op on demand\\r\\n rval = {}\\r\\n for node in self.apply_callcount:\\r\\n if self.apply_cimpl[node]:\\r\\n rval[node.op] = 'C '\\r\\n else:\\r\\n rval[node.op] = 'Py'\\r\\n return rval\",\n \"def test_get_batch_statistics_request(self):\\n self.trans_details.get_batch_statistics(\\n batch_id = 123456,\\n )\",\n \"def calculate(self):\\n pass\",\n \"def completed_operations(self) -> int:\\n return self._completed_operations.value()\",\n \"def test_total_throughput(self):\\n self.query(\\n \\\"CREATE TABLE foobar \\\"\\n \\\"(id STRING HASH KEY, foo NUMBER, THROUGHPUT (1, 1))\\\"\\n \\\"GLOBAL INDEX ('idx', id, foo, THROUGHPUT(1, 1))\\\"\\n )\\n desc = self.engine.describe(\\\"foobar\\\", refresh=True)\\n self.assertEqual(desc.total_read_throughput, 2)\\n self.assertEqual(desc.total_write_throughput, 2)\",\n \"def measure(self):\\n pass\",\n \"def calculateRunTime(function, *args):\\n startTime = time.time()\\n result = function(*args)\\n return time.time() - startTime, result\",\n \"def print_usage(self):\\n print('Total Usage: %f compute seconds' % self.box_usage)\\n cost = self.box_usage * 0.14\\n print('Approximate Cost: $%f' % cost)\",\n \"def stats(self):\\n return self.rpc.call(MsfRpcMethod.CoreModuleStats)\",\n \"def reduce_run():\",\n \"def statistics(self):\\n raise NotImplemented()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7313468","0.7228227","0.7212459","0.7169933","0.6866486","0.6595815","0.6593144","0.6504629","0.64714056","0.6452719","0.6406453","0.6396562","0.6314827","0.6296872","0.62631065","0.6217563","0.6191796","0.61761403","0.6125694","0.61125034","0.6077134","0.6058539","0.60265005","0.6009686","0.60091203","0.60027593","0.5990963","0.59887874","0.5937349","0.58673775","0.58609796","0.58596545","0.58354646","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5820638","0.5817705","0.5787607","0.5769843","0.5759994","0.57227534","0.5720384","0.57061553","0.56953484","0.5683057","0.5680258","0.56644994","0.56608355","0.5640585","0.5625011","0.56146336","0.5613835","0.560519","0.5603093","0.56022906","0.5575908","0.5572","0.55669904","0.5563802","0.55453306","0.5540765","0.5532349","0.55308723","0.5520183","0.5510748","0.5496934","0.5495898","0.5495368","0.54819113","0.5474363","0.5456802","0.54446864","0.5434368","0.54315597","0.54301685","0.54278046","0.5423788","0.54196286","0.5418622","0.54179007","0.54119277","0.54106206","0.5408947","0.5404909"],"string":"[\n \"0.7313468\",\n \"0.7228227\",\n \"0.7212459\",\n \"0.7169933\",\n \"0.6866486\",\n \"0.6595815\",\n \"0.6593144\",\n \"0.6504629\",\n \"0.64714056\",\n \"0.6452719\",\n \"0.6406453\",\n \"0.6396562\",\n \"0.6314827\",\n \"0.6296872\",\n \"0.62631065\",\n \"0.6217563\",\n \"0.6191796\",\n \"0.61761403\",\n \"0.6125694\",\n \"0.61125034\",\n \"0.6077134\",\n \"0.6058539\",\n \"0.60265005\",\n \"0.6009686\",\n \"0.60091203\",\n \"0.60027593\",\n \"0.5990963\",\n \"0.59887874\",\n \"0.5937349\",\n \"0.58673775\",\n \"0.58609796\",\n \"0.58596545\",\n \"0.58354646\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5820638\",\n \"0.5817705\",\n \"0.5787607\",\n \"0.5769843\",\n \"0.5759994\",\n \"0.57227534\",\n \"0.5720384\",\n \"0.57061553\",\n \"0.56953484\",\n \"0.5683057\",\n \"0.5680258\",\n \"0.56644994\",\n \"0.56608355\",\n \"0.5640585\",\n \"0.5625011\",\n \"0.56146336\",\n \"0.5613835\",\n \"0.560519\",\n \"0.5603093\",\n \"0.56022906\",\n \"0.5575908\",\n \"0.5572\",\n \"0.55669904\",\n \"0.5563802\",\n \"0.55453306\",\n \"0.5540765\",\n \"0.5532349\",\n \"0.55308723\",\n \"0.5520183\",\n \"0.5510748\",\n \"0.5496934\",\n \"0.5495898\",\n \"0.5495368\",\n \"0.54819113\",\n \"0.5474363\",\n \"0.5456802\",\n \"0.54446864\",\n \"0.5434368\",\n \"0.54315597\",\n \"0.54301685\",\n \"0.54278046\",\n \"0.5423788\",\n \"0.54196286\",\n \"0.5418622\",\n \"0.54179007\",\n \"0.54119277\",\n \"0.54106206\",\n \"0.5408947\",\n \"0.5404909\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6650646"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":9455,"cells":{"query":{"kind":"string","value":"load data Divide the train set into train set and crossvalidation set in ratio."},"document":{"kind":"string","value":"def load_data(trainfile, testfile):\n raw_train = pd.read_csv(trainfile, header=None)\n raw_test = pd.read_csv(testfile, header=None)\n train = raw_train.values\n test = raw_test.values\n train_features = train[0::, 1::]\n train_label = train[::, 0]\n test_features = test[0::, 1::]\n test_label = test[::, 0]\n train, cv , train_label, cv_label = train_test_split(train_features,train_label, test_size=0.33, random_state=42)\n return train, train_label, \\\n cv, cv_label, \\\n test_features, test_label"},"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 train_test_loaders(dataset, validation_ratio=0.2, **kwargs):\n dataset_size = len(dataset)\n test_size = int(np.floor(validation_ratio * dataset_size))\n train_size = dataset_size - test_size\n print('TRAIN SIZE {}'.format(train_size))\n print('TEST SIZE {}'.format(test_size))\n train_dataset, test_dataset = random_split(dataset, (train_size, test_size),\n generator=torch.Generator().manual_seed(RANDOM_SEED))\n train_loader = torch.utils.data.DataLoader(train_dataset, **kwargs)\n test_loader = torch.utils.data.DataLoader(test_dataset, **kwargs)\n return train_loader, test_loader","def split_data(self):\n if not self.load_data:\n raise AttributeError('Preprocessor has not loaded any data.')\n \n # 3 - Find example counts for each set\n self.n_examples = self.data[0].shape[0]\n self.n_train = int(self.n_examples * self.train_ratio)\n self.n_val = int(self.n_examples * self.val_ratio)\n self.n_test = self.n_examples - self.n_train - self.n_val\n \n logger.info(f'Set sizes:')\n logger.info(f'train: {self.n_train}')\n logger.info(f'val: {self.n_val}')\n logger.info(f'test: {self.n_test}')\n if self.n_test < 0:\n raise ValueError('Train + validation ratios must bef < 1')\n\n # 4 - Separate data into train, test, val\n if isinstance(self.data[0], pd.DataFrame):\n logger.info('Dataset is in a dataframe.')\n self.isdataframe = True\n\n self.train_data = [self.data[0].iloc[:self.n_train],\n self.data[1].iloc[:self.n_train]]\n \n self.val_data = [self.data[0].iloc[self.n_train:self.n_val + self.n_train],\n self.data[1].iloc[self.n_train:self.n_val + self.n_train]]\n \n self.test_data = [self.data[0].iloc[self.n_val + self.n_train:],\n self.data[1].iloc[self.n_val + self.n_train:]]\n logger.info('Data was split into train, val, test.')\n else:\n self.isdataframe = False\n logger.info('Dataset is in a numpy array.')\n \n # If datasets are numpy array or sparse\n self.train_data = [self.data[0][:self.n_train],\n self.data[1][:self.n_train]]\n \n self.val_data = [self.data[0][self.n_train:self.n_val + self.n_train],\n self.data[1][self.n_train:self.n_val + self.n_train]]\n \n self.test_data = [self.data[0][self.n_val + self.n_train:],\n self.data[1][self.n_val + self.n_train:]]\n logger.info('Data was split into train, val, test.')\n \n assert(self.n_train == self.train_data[0].shape[0])\n assert(self.n_val == self.val_data[0].shape[0])\n assert(self.n_test == self.test_data[0].shape[0])\n \n # Free memory\n del self.data\n \n if self.save_sets:\n self.save_datasets()","def readData(path_to_dataset, train_size=0.8, validation_size=0.2):\n data = pd.read_csv(os.path.join(path_to_dataset, 'training_set_rel3.tsv'), sep='\\t', encoding='ISO-8859-1')\n # Drop columns that has null value \n data = data.dropna(axis=1)\n # Only take 4 columns of data from the dataset: essay_id, essay_set, essay, domain1_score\n data = data[['essay_id', 'essay_set', 'essay', 'domain1_score']]\n # Perform 80:20 train-test split on the training data\n train_set, test_set = train_test_split(data, train_size=train_size, random_state=0)\n # Split the 80% training set further into 60:20\n training_set, validation_set = train_test_split(train_set, test_size=validation_size, random_state=0)\n return training_set, test_set, validation_set","def load_data_preprocess(self):\n\n print(\"Loading the dataset ...\")\n # load the data\n c_util = CarUtils()\n train_x, train_y, test_x, test_y, classes = c_util.load_data()\n\n # set the image ordering\n K.set_image_dim_ordering(\"th\")\n\n print(\"Pre-processing the dataset ...\")\n # pre-process the data\n train_x = train_x.astype('float32')\n test_x = test_x.astype('float32')\n\n train_x = train_x / 255\n test_x = test_x / 255\n\n print(train_x.shape[0], ' train samples')\n print(test_x.shape[0], ' test samples')\n\n train_y = np_utils.to_categorical(train_y, CarsClassifierModel._nb_classes)\n test_y = np_utils.to_categorical(test_y, CarsClassifierModel._nb_classes)\n\n return train_x, train_y, test_x, test_y","def _load_data(self):\n pickle_in = open(\"X_train.pickle\", \"rb\")\n self.X = pickle.load(pickle_in)\n pickle_in = open(\"y_train.pickle\", \"rb\")\n self.Y = pickle.load(pickle_in)\n\n pickle_in = open(\"X_test.pickle\", \"rb\")\n self.X_final = pickle.load(pickle_in)\n pickle_in = open(\"y_test.pickle\", \"rb\")\n self.Y_final = pickle.load(pickle_in)\n\n # Set input shape:\n if K.image_data_format() == 'channels_first':\n self.input_shape = (3, self.img_rows, self.img_cols)\n else:\n self.input_shape = (self.img_rows, self.img_cols, 3)\n\n self.X = self.X.astype('float32')\n self.X /= 255\n self.X_final = self.X_final.astype('float32')\n self.X_final /= 255\n print('X shape:', self.X.shape)\n print(self.X.shape[0], 'Samples')\n\n num_datapoints = 3000\n self.X = self.X[0:num_datapoints]\n self.Y = self.Y[0:num_datapoints]\n\n num_datapoints = 2000\n self.X_final = self.X_final[0:num_datapoints]\n self.Y_final = self.Y_final[0:num_datapoints]\n\n self.Y_final = to_categorical(self.Y_final, self.num_classes)\n\n # Initialize Data\n kfold = StratifiedKFold(n_splits=self.nFolds, shuffle=True)\n\n if self.b_eval_advanced:\n # Loop through the indices the split() method returns\n for index, (train_indices, test_indices) in enumerate(kfold.split(self.X, self.Y)):\n if index == 0:\n self.Y = to_categorical(self.Y, self.num_classes)\n\n # Generate batches from indices\n xtrain, xtest = self.X[train_indices], self.X[test_indices]\n ytrain, ytest = self.Y[train_indices], self.Y[test_indices]\n\n self.data.append(tuple([xtrain, xtest, ytrain, ytest]))\n\n if not self.b_eval_advanced:\n self.Y = to_categorical(self.Y, self.num_classes)\n\n #print(np.asarray(self.data).shape)\n #print(self.data)\n print(\"Y_final Shape\", self.Y_final.shape)","def split_data(self):\n self.train, self.val, self.test_x, self.test_y = [], [], [], []\n train_size = self.horizon\n # This assumes all countries have the same length.\n # The minus two gives space for the validation and test sets as they will overshoot.\n k_folds = len(self.countries[0].data)//self.horizon - 2\n for _ in range(k_folds):\n tr, v, te_x, te_y = self.cross_validate(train_size)\n self.train.append(tr), self.val.append(v), self.test_x.append(te_x), self.test_y.append(te_y)\n train_size += self.horizon","def data_split(dataset, val_ratio=0.1, test_ratio=0.1, seed=1234):\n\n\t# How you grab the labels will depend on what type of Pytorch Dataset object 'dataset' is\n\t# (i.e. ImageFolder/DatasetFolder or not)\n\n\t# For fun, check the method resolution order (MRO) of 'dataset'\n\tprint('Dataset object\\'s inheritance: ', type(dataset).__mro__)\n\n\t# Determine what kind of Dataset object it is, then grab labels\n\t# Warning: currently this will break for anything other than an ImageFolder or CIFAR10 train set\n\tif isinstance(dataset, datasets.CIFAR10):\n\t\tlabels = dataset.train_labels\n\telif isinstance(dataset, datasets.ImageFolder):\n\t\tlabels = [img[1] for img in dataset.imgs]\n\telse:\n\t\terror('Dataset not supported yet')\n\n\t# Calculate class priors, (number in class)/(size of dataset)\n\tidcs = [i for i in range(len(dataset))]\n\tsamples_per_class = np.bincount(np.array(labels))\n\tpriors = samples_per_class/len(labels)\n\n\t# Number of samples in each class for val and test set \n\tval_per_class = np.ceil(samples_per_class*val_ratio).astype(np.int)\n\ttest_per_class = np.ceil(samples_per_class*test_ratio).astype(np.int)\n\n\t# Copy and shuffle the labels and corresponding indices to randomize before splitting\n\tshuffled_labels = list(labels)\n\tshuffled_idcs = list(idcs)\n\trandom.Random(seed).shuffle(shuffled_labels)\n\trandom.Random(seed).shuffle(shuffled_idcs)\n\n\t# Iterate through, grabbing indices for each class to place in validation set\n\t# until the desired number is reached\n\tval_idcs = []\n\tval_counts = np.zeros(val_per_class.shape)\n\n\tfor i, l in zip(shuffled_idcs, shuffled_labels):\n\t\t# Check if validation set quota has been reached yet for this class\n\t\tif val_counts[l] < val_per_class[l]:\n\t\t\tval_idcs.append(i)\n\t\t\tval_counts[l] += 1\n\n\t\t# Check if stopping point is reached\n\t\tif (val_counts == val_per_class).all():\n\t\t\tbreak\n\n\t# Repeat for test set\n\ttest_idcs = []\n\ttest_counts = np.zeros(test_per_class.shape)\n\tfor i, l in zip(shuffled_idcs, shuffled_labels):\n\t\t# Check if this index is already in val set\n\t\tif i in val_idcs:\n\t\t\tcontinue\n\n\t\t# Check if test set quota has been reached yet for this class\n\t\tif test_counts[l] < test_per_class[l]:\n\t\t\ttest_idcs.append(i)\n\t\t\ttest_counts[l] += 1\n\n\t\t# Check if stopping point is reached\n\t\tif (test_counts == test_per_class).all():\n\t\t\tbreak\n\n\t# Get train indices too (all the remaining samples not in val or test)\n\ttrain_idcs = [j for j in idcs if j not in val_idcs+test_idcs]\n\n\t# Split the data\n\ttrain = Subset(dataset, train_idcs)\n\tval = Subset(dataset, val_idcs)\n\ttest = Subset(dataset, test_idcs)\n\n\treturn train, val, test","def test_data_set_load(data_set):\n data = data_set()\n train_data, train_labels, test_data, test_labels = data.load_data()\n\n assert len(train_data) > 0\n assert len(test_data) > 0\n assert len(train_data) == len(train_labels)\n assert len(test_data) == len(test_labels)","def create_train_valid_set(self):\n\n if not self.eq_train:\n X_train_high_level, X_valid_high_level, X_train_low_level, X_valid_low_level, train_w, valid_w, y_train, y_valid = train_test_split(self.X_train_high_level, self.X_train_low_level, self.train_weights, self.y_train,\n train_size=0.7, test_size=0.3\n )\n else:\n X_train_high_level, X_valid_high_level, X_train_low_level, X_valid_low_level, train_w, valid_w, w_train_eq, w_valid_eq, y_train, y_valid = train_test_split(self.X_train_high_level, self.X_train_low_level,\n self.train_weights, self.train_weights_eq, self.y_train,\n train_size=0.7, test_size=0.3\n )\n self.train_weights_eq = w_train_eq\n\n #NOTE: might need to re-equalise weights in each folds as sumW_sig != sumW_bkg anymroe!\n self.train_weights = train_w\n self.valid_weights = valid_w #validation weights should never be equalised weights!\n\n print 'creating validation dataset'\n self.X_train_high_level = X_train_high_level\n self.X_train_low_level = self.join_objects(X_train_low_level)\n\n self.X_valid_high_level = X_valid_high_level\n self.X_valid_low_level = self.join_objects(X_valid_low_level)\n print 'finished creating validation dataset'\n\n self.y_train = y_train\n self.y_valid = y_valid","def load_data():\n data = gzip.open(\"mnist.pkl.gz\", \"rb\")\n train_set, valid_set, test_set = cPickle.load(data)\n data.close()\n\n # Combine validation and train folds to recreate the master 60k set.\n new_images = numpy.concatenate((train_set[0], valid_set[0]))\n new_labels = numpy.concatenate((train_set[1], valid_set[1]))\n\n train_set = (new_images, new_labels)\n \n return (train_set, test_set)","def Train_data():\n print (\"loading train data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\n data_real = f['train_real'][:]\n num, nt, ny, nx = data_real.shape\n data_real = np.transpose(data_real, (0, 1, 3, 2))\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\n data_imag = f['train_imag'][:]\n num, nt, ny, nx = data_imag.shape\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\n data = data_real+1j*data_imag\n num_train = 15000\n num_validate = 2000\n train_data = data[0:num_train]\n validate_data = data[num_train:num_train+num_validate]\n\n train_data = np.random.permutation(train_data)\n\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end-time_start))\n return train_data, validate_data","def load_data(self,split='train'):\n raise ValueError('Please implement me!')","def load(self,train_ratio=.9,seed=123):\n\t\tdata_dir = cfg.DATA_DIR\n\n\t\tif isinstance(DATASETS.get(self.data_name),dict):\n\t\t\t\n\t\t\tif len(DATASETS.get(self.data_name))==2: # Relevant only for MNIST\n\t\t\t\ttrain_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('train'))\n\t\t\t\ttest_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('test'))\n\t\t\t\n\t\t\telse: # Only relevant for binarized MNIST\n\t\t\t\ttrain_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('train'))\n\t\t\t\ttest_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('test'))\n\t\t\t\tvalid_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('valid'))\n\t\telse:\n\t\t\tfpath = os.path.join(data_dir,DATASETS.get(self.data_name))\n\n\t\tprint(f\"Trying to load {self.data_name} from directory(ies):\")\n\t\t\n\t\tif self.data_name == \"freyfaces\":\n\t\t\t# Load freyfaces\n\t\t\tprint(f\"...from {os.path.join(data_dir,fpath)}\")\n\t\t\tf = open(fpath,'rb')\n\t\t\tdata = pickle.load(f,encoding='latin1')\n\t\t\tf.close()\n\n\t\t\t# This block is directly from the VRBound repository\n\t\t\tnp.random.seed(seed)\n\t\t\tnp.random.shuffle(data)\n\t\t\tif train_ratio==1 or (0>train_ratio or 1<train_ratio):\n\t\t\t\tprint(f\"Train split ratio {train_ratio} or test value is invalid!\")\n\t\t\t\traise Exception\n\t\t\tnum_train = int(train_ratio* data.shape[0])\n\n\t\t\tdata_train = data[:num_train]\n\t\t\tdata_test = data[num_train:]\n\t\t\t# End of copy\n\n\t\telif self.data_name == \"silhouettes\":\n\t\t\t# Load silhouettes data\n\t\t\tprint(f\"...from {os.path.join(data_dir,fpath)}\")\n\n\t\t\t# These lines are also from VRBound repository\n\t\t\tdata = loadmat(fpath) \n\t\t\tdata = 1-data.get('X')\n\n\t\t\t# This block is directly from the VRBound repository\n\t\t\tnp.random.seed(seed)\n\t\t\tnp.random.shuffle(data)\n\t\t\tif train_ratio==1 or (0>train_ratio or 1<train_ratio):\n\t\t\t\tprint(f\"Train split ratio {train_ratio} or test value is invalid!\")\n\t\t\t\traise Exception\n\t\t\tnum_train = int(train_ratio* data.shape[0])\n\n\n\t\t\tdata_train = data[:num_train]\n\t\t\tdata_test = data[num_train:]\n\t\t\t# End of copy\n\n\t\telif self.data_name == \"mnist\":\n\t\t\tprint(\"MNIST data is already train/test split - training ratio input ignored!\")\n\t\t\tprint(f\"...from {os.path.join(data_dir,DATASETS.get(self.data_name)['train'])}\")\n\n\t\t\tdata_train, _ = MNIST(train_fpath).load_training() # We don't care about what the labels are; overwrite\n\t\t\tdata_test, _ = MNIST(test_fpath).load_testing()\n\n\t\telif self.data_name == \"mnist_binary\":\n\t\t\tprint(\"MNIST data is already train/test split - training ratio input ignored!\")\n\t\t\tprint(f\"...from {os.path.join(train_fpath.split('/')[-2])}\")\n\t\t\t# This is directly from the iwae codebase\n\t\t\tdef lines_to_np_array(lines):\n\t\t\t return np.array([[int(i) for i in line.split()] for line in lines])\n\t\t\twith open(train_fpath) as f:\n\t\t\t lines = f.readlines()\n\t\t\ttrain_data = lines_to_np_array(lines).astype('float32')\n\t\t\twith open(test_fpath) as f:\n\t\t\t lines = f.readlines()\n\t\t\tvalidation_data = lines_to_np_array(lines).astype('float32')\n\t\t\twith open(valid_fpath) as f:\n\t\t\t lines = f.readlines()\n\t\t\tdata_test = lines_to_np_array(lines).astype('float32')\n\n\t\t\tdata_train= np.concatenate([train_data, validation_data], axis=0)\n\n\t\telif self.data_name == \"omniglot\":\n\t\t\tprint(f\"...from {os.path.join(data_dir,fpath)}\")\n\t\t\tprint(\"Omniglot data is already train/test split - training ratio input ignored!\")\n\n\t\t\tdata = loadmat(fpath)\n\n\t\t\t# From iwae repository\n\t\t\tdata_train = data['data'].T.astype('float32').reshape((-1, 28, 28)).reshape((-1, 28*28), order='F') \n\t\t\tdata_test = data['testdata'].T.astype('float32').reshape((-1, 28, 28)).reshape((-1, 28*28), order='F')\n\t\t\n\t\treturn data_train, data_test","def load_data(opt=\"mnist\"):\n if opt == \"mnist\":\n train, test = tf.keras.datasets.mnist.load_data()\n \n x_train, y_train = train\n x_test, y_test = test\n \n x_train = x_train.reshape(x_train.shape[0], 28 * 28)\n x_test = x_test.reshape(x_test.shape[0], 28 * 28)\n \n y_train = y_train.astype(np.int)\n y_test = y_test.astype(np.int)\n for i in range(len(y_train)):\n y_train[i] = 1 if y_train[i] % 2 == 0 else -1\n for i in range(len(y_test)):\n y_test[i] = 1 if y_test[i] % 2 == 0 else -1\n\n elif opt == \"covertype\":\n df = pd.read_csv(\"covtype.data\", header=None)\n x = df.iloc[:, 0:54].values\n y = df[54].values\n for i in range(len(y)):\n y[i] = 1 if y[i] % 2 == 0 else -1\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\n \n else:\n logging.error(\"Unknown dataset!!\")\n\n logging.info(\"train data shape: {}\".format(x_train.shape))\n logging.info(\"test data shape: {}\".format(x_test.shape))\n return (x_train, y_train), (x_test, y_test)","def load_dataset(split_ratio, save_root_dir):\n # Set the processed data directories\n train_ct, train_label_map, test_ct, test_label_map = train_test_split(split_ratio=split_ratio,\n save_root_dir=save_root_dir)\n\n train_dataset = train_label_map, train_ct\n test_dataset = test_label_map, test_ct\n return train_dataset, test_dataset","def __split_dataset(self):\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)","def train_val_split(dataset, train_val_split_ratio: float, batch_size: int):\n num_files = len(dataset)\n indices = list(range(num_files))\n split = int(np.floor(train_val_split_ratio * num_files))\n np.random.shuffle(indices)\n train_idx, val_idx = indices[split:], indices[:split]\n train_sampler = SubsetRandomSampler(train_idx)\n val_sampler = SubsetRandomSampler(val_idx)\n\n train_dataloader = torch.utils.data.DataLoader(dataset, sampler=train_sampler, batch_size=batch_size)\n val_dataloader = torch.utils.data.DataLoader(dataset, sampler=val_sampler, batch_size=batch_size)\n return train_dataloader, val_dataloader","def _split_data(self):\n\n # Set training data\n self.train_data = torchvision.datasets.ImageFolder(\n os.path.join(self.path, 'train'),\n transform=self._transform()\n )\n self.classes = self.train_data.classes\n\n # Set validation data\n self.val_data = torchvision.datasets.ImageFolder(\n os.path.join(self.path, 'test'),\n transform=self._transform(train=False)\n )","def data_set_maker():\n\n # crate a folder in your code directory and name it: \"files\". put the .npy files iside that folder\n\n x_all = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\n y_all = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\n\n # split the data into 10% validation-set and 90% training set\n raw_train, raw_valid, y_train, y_valid = train_test_split(x_all, y_all, test_size=0.2, random_state=43)\n return raw_train, raw_valid, y_train, y_valid","def loadData(self):\n batch_size = 256\n \n #if self.conv_sg == True:\n # batch_size = 1 \n \n download = True\n root = self.root + self.dataset\n if self.dataset == \"MNIST\": \n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR10\":\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\n \n if self.dataset == \"CIFAR100\":\n transform = transforms.Compose([transforms.ToTensor()])\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\n \n \n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\n shuffle=False, num_workers=0, pin_memory = False)\n \n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\n shuffle=False, num_workers=2, pin_memory = False)\n \n return trainloader, testloader","def initSets(self):\n data_frame = pd.read_csv(self.train_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n if self.test_file is None:\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n else:\n data_frame = pd.read_csv(self.test_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n # kfold = KFold(n_splits=3)\n # self.train_index, self.test_index = kfold.split(features,labels)","def load_data(self):\n\n self._load_train_data()\n self._load_test_data()","def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\n stratified=False, random_seed=None, batch_size = 64,\n maxsize = None, maxsize_test=None, num_workers = 0):\n\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\n\n if type(train.targets) is list or type(train.targets) is np.ndarray:\n train.targets = torch.LongTensor(train.targets)\n test.targets = torch.LongTensor(test.targets)\n\n if not hasattr(train, 'classes') or not train.classes:\n train.classes = sorted(torch.unique(train.targets).tolist())\n test.classes = sorted(torch.unique(train.targets).tolist())\n\n ### Data splitting\n fold_idxs = {}\n if splits is None and valid_size == 0:\n ## Only train\n fold_idxs['train'] = np.arange(len(train))\n elif splits is None and valid_size > 0:\n ## Train/Valid\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\n fold_idxs['train'] = train_idx\n fold_idxs['valid'] = valid_idx\n\n for k, idxs in fold_idxs.items():\n if maxsize and maxsize < len(idxs):\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\n\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\n\n ### Create DataLoaders\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\n\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\n for k,sampler in fold_samplers.items()}\n\n if maxsize_test and maxsize_test < len(test):\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\n dataloader_args['sampler'] = sampler_test\n else:\n dataloader_args['shuffle'] = False\n test_loader = dataloader.DataLoader(test, **dataloader_args)\n fold_loaders['test'] = test_loader\n\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\n fnames = '/'.join(list(fnames) + ['test'])\n flens = '/'.join(map(str, list(flens) + [len(test)]))\n\n if hasattr(train, 'data'):\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\n print(f'Fold Sizes: {flens} ({fnames})')\n\n return fold_loaders, {'train': train, 'test':test}","def data_split(data, labels, train_ratio=0.5, rand_seed=42):\n\n assert 0 <= train_ratio <= 1, \"Error: training set ratio must be between 0 and 1\"\n\n x_train, x_temp, y_train, y_temp = train_test_split(data,\n labels,\n train_size=train_ratio,\n random_state=rand_seed)\n\n x_val, x_test, y_val, y_test = train_test_split(x_temp,\n y_temp,\n train_size=0.5,\n random_state=rand_seed)\n\n return x_train, x_val, x_test, y_train, y_val, y_test","def load_data(train=True):\n#test set\n start = time.clock()\n\n if train==False:\n dp = '/home/thomas/Desktop/OttoChallenge/test.csv'\n df = pd.read_csv(dp)\n X = df.values.astype(np.float32)[:,1:]\n return X\n#train set\n else:\n dp = '/home/thomas/Desktop/OttoChallenge/train.csv'\n df = pd.read_csv(dp)\n X = df[df.columns[:-1]].values.astype(np.float32)[:,1:]\n y = df.target\n y =y.apply(lambda X: int(X[-1])).values\n y = y.astype(np.int32)\n X, y = shuffle(X, y)\n #print(X.shape,y.shape)\n end = time.clock()\n print(end-start)\n\n return X,y","def load_data(self,split='train'):\n raise NotImplementedError","def load_dataset(data_dir, img_size):\n global input_set\n global test_set\n\n imgs = []\n img_files = os.listdir(data_dir)\n for img in img_files:\n # try:\n tmp = scipy.misc.imread(data_dir + \"/\" + img)\n x, y, z = tmp.shape # shape : width * length * chanel\n coords_x = int(x / img_size) # 坐标\n coords_y = int(y / img_size) #\n coords = [(q, r) for q in range(coords_x) for r in range(coords_y)] # 列表 x * y\n for coord in coords:\n imgs.append((data_dir + \"/\" + img, coord)) # 为列表添加文件目录\n # except BaseException:\n # print(\"oops\")\n test_size = min(10, int(len(imgs) * 0.2))\n random.shuffle(imgs)\n test_set = imgs[:test_size]\n train_set_X = imgs[test_size:][:200]\n train_set = imgs[test_size:][200:400]\n return","def train_and_test(self, data):\n\n np.random.shuffle(data)\n datalist = self.unpack_data(data)\n\n logger.info('[*] 75-25 partition of datasets ...')\n\n markline1 = math.floor(0.75*(len(datalist['features'])))\n markline2 = math.floor(0.75*len(datalist['labels']))\n\n train_features = datalist['features'][:(markline1)]\n test_features = datalist['features'][(markline1):]\n \n train_labels = datalist['labels'][:(markline2)]\n test_labels = datalist['labels'][(markline2):]\n\n logger.info('[*] Training started with 75% Dataset ...')\n\n self.knn_model.fit(train_features, train_labels)\n\n logger.info('[*] Testing started with 25% Dataset ...')\n print('\\n/---------------Accuracy----------------/') \n \n accuracy = self.knn_model.score(train_features, train_labels)\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\n\n if accuracy < 0.40:\n logger.warning('[-.-!] Thanks for tryin\\' but this machine ain\\'t learning.')\n\n return True","def load_dataset(self):\n # Get all the files in the directory\n file_list = self.get_file_list()\n\n # Concatenate the data corresponding to a list of files\n data = self.concatenate_file_data(file_list)\n\n # Shuffle the data and create the training and the validation datasets\n data = self.shuffle_data_dictionary(data)\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)","def load_train_data():\r\n X_train = np.load('data/train/X_train.npy')\r\n scaling_train = np.load('data/train/scaling_train.npy')\r\n ids_train = np.load('data/train/ids_train.npy')\r\n y_train = np.load('data/train/y_train.npy')\r\n\r\n seed = np.random.randint(1, 10e6)\r\n np.random.seed(seed)\r\n np.random.shuffle(X_train)\r\n np.random.seed(seed)\r\n np.random.shuffle(scaling_train)\r\n np.random.seed(seed)\r\n np.random.shuffle(ids_train)\r\n np.random.seed(seed)\r\n np.random.shuffle(y_train)\r\n\r\n return X_train, scaling_train, ids_train, y_train","def partition_train_valid_test2(data, classes, others, ratio=(1,1,1), rng=np.random.RandomState(1000)):\n k=sum(ratio) # ratio must be a vector of integers\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\n sequence=np.arange(len(classes))\n train_ind=np.array([],dtype=int)\n valid_ind=np.array([],dtype=int)\n test_ind=np.array([],dtype=int)\n count=0\n for ki in range(k):\n if count<ratio[0]:\n train_ind=np.append(train_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\n valid_ind=np.append(valid_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\n test_ind=np.append(test_ind,sequence[ind==ki])\n count=count+1\n continue\n train_set_x=data[train_ind]\n train_set_y=classes[train_ind]\n if others is not None:\n train_set_others=others[train_ind]\n else:\n train_set_others=None\n valid_set_x=data[valid_ind]\n valid_set_y=classes[valid_ind]\n if others is not None:\n valid_set_others=others[valid_ind]\n else:\n valid_set_others=None\n test_set_x=data[test_ind]\n test_set_y=classes[test_ind]\n if others is not None:\n test_set_others=others[test_ind]\n else:\n test_set_others=None\n \n return train_set_x,train_set_y,train_set_others,valid_set_x,valid_set_y,valid_set_others,test_set_x,test_set_y,test_set_others","def partition_train_valid_test(data, classes, ratio=(1,1,1), rng=np.random.RandomState(1000)):\n k=sum(ratio) # ratio must be a vector of integers\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\n sequence=np.arange(len(classes))\n train_ind=np.array([],dtype=int)\n valid_ind=np.array([],dtype=int)\n test_ind=np.array([],dtype=int)\n count=0\n for ki in range(k):\n if count<ratio[0]:\n train_ind=np.append(train_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\n valid_ind=np.append(valid_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\n test_ind=np.append(test_ind,sequence[ind==ki])\n count=count+1\n continue\n train_set_x=data[train_ind]\n train_set_y=classes[train_ind]\n valid_set_x=data[valid_ind]\n valid_set_y=classes[valid_ind]\n test_set_x=data[test_ind]\n test_set_y=classes[test_ind]\n return train_set_x,train_set_y,valid_set_x,valid_set_y,test_set_x,test_set_y","def _load_data(self):\n if self._name in BALANCE_DATASET:\n _loader = dataset_loaders[self._name]\n xnp, y = _loader()\n\n # Train - Test split\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\n train_idx, test_idx = next(gen)\n\n # Train data.\n self.xnp_tr = xnp[train_idx]\n self.y_tr = y[train_idx]\n # Test data.\n self.xnp_ts = xnp[test_idx]\n self.y_ts = y[test_idx]\n\n else:\n _loader = dataset_loaders[self._name]\n xnp, xp, y = _loader()\n # self.xnp, self.xp, self.y = _loader()\n\n # Train - Test split\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\n train_idx, test_idx = next(gen)\n\n # Train data.\n self.xnp_tr = xnp[train_idx]\n self.xp_tr = xp[train_idx]\n self.y_tr = y[train_idx]\n # Test data.\n self.xnp_ts = xnp[test_idx]\n self.xp_ts = xp[test_idx]\n self.y_ts = y[test_idx]","def load_occupancy_dataset(trainsize=500, testsize=1000):\n filename = 'datasets/numericsequence.csv'\n dataset = loadcsv(filename)\n trainset, testset = splitdataset(dataset, trainsize, testsize)\n return trainset, testset","def prepare_dataset(data_path, test_size=0.2, validation_size=0.2):\r\n\r\n # load dataset\r\n if data_path.endswith('json'):\r\n X, y = load_data_from_json(data_path)\r\n else:\r\n X, y = load_data_from_fold(data_path)\r\n # create train, validation, test split\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size)\r\n X_train, X_validation, y_train, y_validation = train_test_split(X_train, y_train, test_size=validation_size)\r\n\r\n # add an axis to nd array\r\n X_train = X_train[..., np.newaxis]\r\n X_test = X_test[..., np.newaxis]\r\n X_validation = X_validation[..., np.newaxis]\r\n\r\n return X_train, y_train, X_validation, y_validation, X_test, y_test","def load_data(self):\n with open('data/fordTrain.csv') as f:\n data = csv.reader(f, delimiter=',')\n train = [x for i, x in enumerate(data) if i > 0] \n # Extract features and target variable separately\n trainx = [x[3:] for x in train]\n trainy = [x[2] for x in train]\n\n with open('data/fordTest.csv') as f:\n data = csv.reader(f, delimiter=',')\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \n\n with open('data/Solution.csv') as f:\n data = csv.reader(f, delimiter=',')\n testy = [x[2] for i, x in enumerate(data) if i > 0] \n\n # Extract features and target variable, convert to numpy array\n trainx = np.asarray(trainx, dtype=np.float32)\n trainy = np.asarray(trainy, dtype=np.int8)\n testx = np.asarray(testx, dtype=np.float32)\n testy = np.asarray(testy, dtype=np.int8)\n\n # Return training and test sets\n trainSet = Dataset(trainx, trainy)\n testSet = Dataset(testx, testy)\n return trainSet, testSet","def load_data(args):\n data_df = pd.read_csv(os.path.join(args.data_dir, 'driving_log.csv'))\n\n X = data_df[['center', 'left', 'right']].values\n y = data_df['steering'].values\n\n X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=args.test_size, random_state=0)\n\n return X_train, X_valid, y_train, y_valid","def _load_train_data(self):\n\n self.train_loader = data.Train_loader(self.N_max, self.n_per_conn,\n self.data_path, self.device)\n self.train_loader.load_data()\n\n # load mean and std\n scc_mean_std = np.loadtxt(\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\n self.mean = torch.Tensor(scc_mean_std[0])\n self.std = torch.Tensor(scc_mean_std[1])","def load_data(self):\n sets = ['train', 'val']\n images = []\n labels = []\n self.labels_dic = {}\n file = open(self.path + 'wnids.txt')\n train_labels = file.read().split()\n if self.train:\n for fn in range(self.num_classes):\n f = train_labels[fn]\n for i in os.listdir(self.path + 'train/' + f + '/images/'):\n images.append(Image.open(self.path + 'train/' + f + '/images/' + i))\n labels.append(f)\n #image label n link to folder names of TinyImageNet\n self.labels_dic[f] = fn\n\n else:\n for fn in range(self.num_classes):\n f = train_labels[fn]\n self.labels_dic[f] = fn\n file_val = open(self.path + 'val/val_annotations.txt')\n val_labels = file_val.read().split('\\n')\n for im in val_labels:\n im_data = im.split(\"\t\")[:2]\n if len(im_data) < 2:\n continue\n if im_data[1] in self.labels_dic:\n images.append(Image.open(self.path + 'val/images/' + im_data[0]))\n labels.append(im_data[1])\n\n self.images = images\n self.labels = labels","def load_data():\n directories=[\"./track1/\",\n \"./track1_recovery/\",\n \"./track2/\",\n \"./track1_reverse/\",\n \"./track2_reverse/\",#Additional data for model built on top of lenet.h5\n \"./track2_recovery/\",#Additions data for model built on top of lenet.h5\n ]\n lines=[]\n for directory in directories:\n with open(directory+\"driving_log.csv\") as csvfile:\n reader=csv.reader(csvfile)\n for line in reader:\n lines.append(line)\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\n return train_samples, validation_samples","def load_data(data_dir, split=1.0):\n n = 123 * 41\n positive_examples = glob.glob(data_dir + '/positive_set/*.png')\n negative_examples = glob.glob(data_dir + '/negative_set/*.png')\n x = np.zeros((n, len(positive_examples) + len(negative_examples)))\n for k in range(len(positive_examples)):\n x[:,k] = np.reshape(img.imread(positive_examples[k]), (n,))\n for k in range(len(negative_examples)):\n x[:, k+len(positive_examples)] = np.reshape(img.imread(negative_examples[k]), (n,))\n y = np.concatenate((np.ones((1,len(positive_examples))), np.zeros((1,len(negative_examples)))), axis=1)\n arr = np.concatenate((x,y), axis=0)\n part_train = int(math.floor(split * arr.shape[1]))\n np.random.shuffle(arr.T)\n x_train = arr[0:-1,0:part_train]\n y_train = arr[-1,0:part_train]\n x_test = arr[0:-1,part_train:]\n y_test = arr[-1,part_train:]\n if split == 1.0:\n return (x_train.T, y_train.T)\n else:\n return (x_train.T, y_train.T),(x_test.T,y_test.T)","def load(train_file, test_file):\n print('\\nLoad the raw training and test set data...')\n y_train, tx_train, ids_train = load_csv_data(train_file)\n y_test, tx_test, ids_test = load_csv_data(test_file)\n print('\\n... finished.')\n return y_train, tx_train, ids_train, y_test, tx_test, ids_test","def load_data():\r\n train_dataset = h5py.File('train_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\r\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\r\n\r\n test_dataset = h5py.File('test_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\r\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\r\n\r\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\r\n \r\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\r\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\r\n \r\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes","def _load_test_data(self):\n\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\n self.data_path, self.device)\n\n self.test_loader.load_data()\n\n # load mean and std from train\n scc_mean_std = np.loadtxt(\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\n self.mean = torch.Tensor(scc_mean_std[0])\n self.std = torch.Tensor(scc_mean_std[1])","def trainAndCalculate(self):\n f = open(\"congressional_voting_dataset.csv\")\n data = np.genfromtxt(fname = f, delimiter=',', dtype=str, encoding=None)\n X = data[:, :-1]\n y = data[:, -1]\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)\n self.svclassifier.fit(X_train, y_train)","def load_data(n_folds=10):\n\n sss = sssplit(n_splits=n_folds, test_size=.1, random_state=np.random.RandomState(830452))\n X, y = get_transformed_data()\n (X_train, y_train), (X_test, y_test) = ([],[]),([],[])\n\n for train_idx, test_idx in sss.split(X, y):\n X_train.append(X[train_idx])\n y_train.append(y[train_idx])\n X_test.append(X[test_idx])\n y_test.append(y[test_idx])\n\n return (X_train, y_train), (X_test, y_test)","def run_train_test_split():\n # Load all documents\n conn = sq.connect(config.DB_FILE)\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\n\n # Identify unique review IDs\n review_ids = documents['review_id'].unique()\n\n # Set seed for random sampling\n np.random.seed(2)\n\n # List of Reviews in the partial data set and full data set\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\n full_set = list(review_ids.copy())\n\n # Load array (X) and labels (Y) of all documents\n with (open(config.DOC_TERM_MATRIX, \"rb\")) as openfile:\n X = pickle.load(openfile)\n\n y = documents['included']\n\n # Train-test split of the partial dataset\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\n\n # Train-test split of the full dataset\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)","def cross_validation_datasets(self, fold):\n if fold > len(self): fold = len(self) / 2\n stratified = self.stratified_bunches(fold)\n datasets = []\n for index in range(len(stratified)):\n gold = GoldInstances(training_as_gold(stratified[index]))\n rest = flatten(stratified[:index]) + flatten(stratified[index + 1:])\n training = TrainingInstances(rest)\n datasets.append((training, gold))\n return datasets","def load_data(train_path, test_path):\n\n train_data = pd.read_csv(train_path)\n test_data = pd.read_csv(test_path)\n\n print(\"number of training examples = \" + str(train_data.shape[0]))\n print(\"number of test examples = \" + str(test_data.shape[0]))\n print(\"train shape: \" + str(train_data.shape))\n print(\"test shape: \" + str(test_data.shape))\n\n return train_data, test_data","def load_data(train_path, test_path):\n\n train_data = pd.read_csv(train_path)\n test_data = pd.read_csv(test_path)\n\n print(\"number of training examples = \" + str(train_data.shape[0]))\n print(\"number of test examples = \" + str(test_data.shape[0]))\n print(\"train shape: \" + str(train_data.shape))\n print(\"test shape: \" + str(test_data.shape))\n\n return train_data, test_data","def split_train_val(self,ratio=.1):\n lim = int(np.ceil(len(self.train) * ratio))\n order = list(range(len(self.train)))\n np.random.shuffle(order)\n self.train_train = self.train.ix[order[lim:]]\n self.train_val = self.train.ix[order[:lim]]\n log(\"Split data into training/val: {} -> {} {}\".format(\n len(self.train),len(self.train_train),lim))","def load_train_test_transactions(train_size=0.7):\n X, y = features_target_split()\n X_train, X_test, y_train, y_test = train_test_split(X,y,train_size=train_size, random_state=7)\n print('\\nTraining and testing data creation successful\\n')\n return X_train, X_test, y_train,y_test","def train_model(self, data_loader):\n train_squared_loss = 0\n correct = 0\n total = 0\n\n self.train()\n for user, item, rating in data_loader:\n self.optimizer.zero_grad()\n\n forward = self(user, item)\n predicted = self._prob_to_class(forward)\n loss = self.loss(forward, rating)\n\n train_squared_loss += loss.item() * len(user)\n total += predicted.numel()\n correct += (predicted == rating.view(-1)).sum().item()\n\n loss.backward()\n self.optimizer.step()\n\n mean_loss = train_squared_loss / total\n\n return mean_loss, f\"{(100 * correct / total):.2f}\"","def _load_data(self, X, y):\n self.Xtrain = X\n\n # y if categories, needs to be transformed to number before fit\n self.le = LabelEncoder()\n self.ytrain = self.le.fit_transform(y)","def load_data():\n # Load data\n X_train = pd.read_csv(\n \"data/trimmed_merged_no_track_id_or_session_id.csv\"\n ) # load data from csv\n\n drop_columns = [\"mode\"] # drop unimportant columns\n X_train.drop(labels=drop_columns, axis=1, inplace=True)\n\n y_train = X_train[\"skip\"]\n X_train.drop(labels=\"skip\", axis=1, inplace=True) # ground truth from train_data\n\n # split data 60% train, 20% validation, 20% test\n X_train, X_val, y_train, y_val = train_test_split(\n X_train, y_train, test_size=0.2, random_state=1\n )\n X_train, X_test, y_train, y_test = train_test_split(\n X_train, y_train, test_size=0.25, random_state=1\n )\n\n print(\"X_train:\", len(X_train))\n print(\"y_train:\", len(y_train))\n print(\"X_val:\", len(X_val))\n print(\"y_val:\", len(y_val))\n print(\"X_test:\", len(X_test))\n print(\"y_test:\", len(y_test))\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def load_data(self):\n print('Loading {} dataset'.format(self.split))\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\n with open(data_split_path,'r') as f:\n reader = csv.reader(f, delimiter=',')\n data_classes = {}\n for i,row in enumerate(reader):\n if i==0:\n continue\n data_classes[row[1]] = 1\n data_classes = data_classes.keys()\n print(data_classes)\n\n n_classes = len(data_classes)\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if self.n_unlabel>0:\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n dataset_u = []\n\n for i, cls in enumerate(data_classes):\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\n for j, im_file in enumerate(im_files):\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \n np.float32, copy=False)\n if j<self.n_label:\n dataset_l[i, j] = im\n else:\n dataset_u[i,j-self.n_label] = im\n print('labeled data:', np.shape(dataset_l))\n print('unlabeled data:', np.shape(dataset_u))\n \n self.dataset_l = dataset_l\n self.dataset_u = dataset_u\n self.n_classes = n_classes","def train_with_loader(self, data, validating_data=None, scheduler=None, epochs=1):\n print('Training...')\n for epoch in range(epochs):\n self.train()\n for train_in, train_out in data:\n self.compute_loss(train_in, train_out, is_guess=False, training=True)\n self.eval()\n if validating_data:\n with torch.no_grad():\n valid_loss = self.compute_loss_loader(validating_data).item()\n print('Average validation error at step ',epoch+1,': ', valid_loss)\n if scheduler and valid_loss:\n scheduler.step()","def load_data(input_file, test_size, random_seed ):\n ratings = np.genfromtxt(input_file, delimiter=',')\n #ratings = ratings[:200,:]\n train_masks = np.zeros_like(ratings)\n test_masks = np.zeros_like(ratings)\n pairs = list()\n for i in range(ratings.shape[0]):\n for j in range(ratings.shape[1]):\n pairs.append((i,j))\n train, test = train_test_split(pairs ,test_size = test_size, random_state= random_seed)\n for user,item in train:\n train_masks[user, item]= 1\n for user,book in test:\n test_masks[user, item]= 1 \n return ratings, train_masks, test_masks","def split_data(data,param):\n all_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled', 'OP2_scaled']][:55]\n all_y = data[[param]][:55]\n return cross_validation.train_test_split(all_x, all_y, test_size=0.2, random_state=0)","def get_training_and_testing_sets(data, Y):\r\n data = pd.concat([data, Y], axis=1)\r\n x,y=data.shape\r\n train_X_sub1=data[0:x//6]\r\n dev_X_sub1 = data[x//6:x//6 + x//12]\r\n test_X_sub1 = data[x//6 + x//12:x//3]\r\n\r\n train_X_sub2 = data[x//3:x//3+x//6]\r\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\r\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\r\n\r\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\r\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\r\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\r\n\r\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\r\n train_X =train_X.append(train_X_sub3,ignore_index = True)\r\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\r\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\r\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\r\n test_X = test_X.append(test_X_sub3,ignore_index = True)\r\n\r\n\r\n train_X = util.shuffle(train_X)\r\n train_X = train_X.reset_index(drop=True)\r\n\r\n dev_X = util.shuffle(dev_X)\r\n dev_X = dev_X.reset_index(drop=True)\r\n\r\n test_X = util.shuffle(test_X)\r\n test_X = test_X.reset_index(drop=True)\r\n\r\n train_X_final=train_X\r\n dev_X_final = dev_X\r\n test_X_final = test_X\r\n x, y = train_X_final.shape\r\n train_X = train_X_final.iloc[:, 0:y - 1]\r\n train_Y = train_X_final.iloc[:, y - 1]\r\n\r\n x, y = test_X_final.shape\r\n test_X = test_X_final.iloc[:, 0:y - 1]\r\n test_Y = test_X_final.iloc[:, y - 1]\r\n\r\n x, y = dev_X_final.shape\r\n dev_X = dev_X_final.iloc[:, 0:y - 1]\r\n dev_Y = dev_X_final.iloc[:, y - 1]\r\n\r\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y","def load_data(data_path):\n headers = ['center', 'left', 'right','steering','throttle','brake','speed']\n data = pd.read_csv(data_path + '/driving_log.csv', names = headers)\n \n # Use SciKit not keras splitting so it randomly selects validation set\n d_train, d_valid = train_test_split(data, test_size=0.2, random_state=42)\n\n return d_train, d_valid","def fit(self, data_loader):\n train_data, valid_data = data_loader.load()\n\n self.compile(self.optimizer, self.loss)\n super().fit(\n x=train_data,\n validation_data=valid_data,\n validation_steps=32, # validate 32 batches at a time\n validation_freq=1, # validate every 1 epoch\n epochs=self.hparams.num_epochs,\n shuffle=False, # dataset instances already handle shuffling\n )\n self.save()","def load_data(train_data,limit=0, split=0.8):\n # Partition off part of the train data for evaluation\n #random.shuffle(train_data)\n train_data = train_data[-limit:]\n Y,X = train_data[\"type\"], train_data[\"posts\"]\n y = []\n for y_ in Y:\n if y_[0] == 'I' : INTROVERTED = True\n else: INTROVERTED = False\n if y_[1] == 'N' : INTUTIVE= True\n else: INTUTIVE= False\n if y_[2] == 'T' : THINKING= True\n else: THINKING= False\n if y_[3] == 'J' : JUDGEMENTAL= True\n else: JUDGEMENTAL= False\n y.append({'INTROVERTED':INTROVERTED,\"INTUTIVE\":INTUTIVE,\"THINKING\":THINKING,\"JUDGEMENTAL\":JUDGEMENTAL})\n\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split, random_state=42)\n return (X_train, y_train), (X_test, y_test)","def _load_training_and_test_sets(normalize):\n class_labels = []\n test_labels = []\n norm = None\n if normalize == True:\n norm = loading.get_normalize_vector()\n\n for i in range(0, 10):\n [training, test] = loading.load_number_set(i, 0.7, norm_vector=norm)\n labels = [str(i)] * training.shape[0]\n tlabels = [str(i)] * test.shape[0]\n if i == 0:\n train_points = training\n test_points = test\n else:\n train_points = np.concatenate((train_points, training), axis = 0)\n test_points = np.concatenate((test_points, test), axis = 0)\n class_labels.extend(labels)\n test_labels.extend(tlabels)\n\n return train_points, test_points, class_labels, test_labels","def cross_validation(self, stock_data):\n\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)","def train_validation_split(data_path, train_path, validation_path, train_samples, validation_samples, sample_type='jpg'):\n remove_files_in_folder(train_path)\n remove_files_in_folder(validation_path)\n \n print(f\"Doing train/validation split. {len(train_samples)} training samples, {len(validation_samples)} validation samples.\")\n for fi in tqdm(os.listdir(data_path)):\n if fi.endswith(sample_type):\n obj = fi.split('.')\n try:\n ind = int(obj[0])\n except:\n continue\n if ind in train_samples:\n copyfile(os.path.join(data_path, fi), os.path.join(train_path, fi))\n \n if ind in validation_samples:\n copyfile(os.path.join(data_path, fi), os.path.join(validation_path, fi))","def load_data(filename, split = 0.9):\n (black, white, player, move, ko) = read_file(filename)\n dataset = zip(black, white, player, move, ko)\n train_data = dataset[:int(math.ceil(split*len(dataset)))]\n test_data = dataset[int(math.ceil(split*len(dataset))):]\n return train_data, test_data","def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\n train_size = int(len(data) * ratio)\n val_size = len(data) - train_size\n train_set, val_set = random_split(data, [train_size, val_size])\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\n return data_train_loader, data_val_loader","def load_dataset():\n\n\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\n collate_fn=PadCollate())\n\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\n collate_fn=PadCollate())\n\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\n\n return train_dd_loader, train_dataloader, test_dataloader","def train_val_split(self):\n idx = np.arange(self.num_data)\n np.random.shuffle(idx)\n val_num = int(self.ratio * self.num_data)\n dev_num = int(self.dev_ratio * self.num_data)\n self.num_train = self.num_data - val_num\n\n self.val_data = self.data[idx[:val_num]]\n self.val_label = self.label[idx[:val_num]]\n \n self.train_data = self.data[idx[val_num:]]\n self.train_label = self.label[idx[val_num:]]\n\n self.dev_data = self.data[idx[:dev_num]]\n self.dev_label = self.label[idx[:dev_num]]","def train(self, data):\n pass","def test__load_training_set():\n classifier = classifier_module.Classifier(None)\n set = classifier._load_training_set('test')\n for i in range(0, 5):\n signal_list = set[i]\n assert signal_list[0].get_x() == 1.0 + i * 0.028\n assert signal_list[0].get_y() == 1.00 - i * i * 0.20 * 0.30\n\n assert signal_list[1].get_x() == 2.0 - i * 0.011\n assert signal_list[1].get_y() == 2.00 - i * 0.020","def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\n distribute_training=False):\n train_set = np.array(train_set)\n test_set = np.array(test_set)\n\n print(\"The shape of training set before dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set before dimension reduction is {0}\".format(test_set.shape))\n print('Use distribute training ? >> {0}'.format(distribute_training))\n reg = linear_model.BayesianRidge()\n\n if dimension_reduce:\n pca = PCA(n_components=128)\n train_set = pca.fit_transform(train_set)\n test_set = pca.fit_transform(test_set)\n\n print(\"The shape of training set after dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set after dimension reduction is {0}\".format(test_set.shape))\n\n if not distribute_training:\n reg.fit(train_set, train_label)\n else:\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\n train_label), da.array(test_label)\n reg.fit(train_set, train_label)\n\n predicted_label = reg.predict(test_set)\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\n\n mkdirs_if_not_exist('./model')\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\n print('The regression model has been persisted...')\n\n mkdirs_if_not_exist('./result')\n\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\n\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\n df.to_csv('./result/%s.csv' % data_name, index=False)\n print('The result csv file has been generated...')","def train(self, training_data):\n pass","def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\n assert step in ['train', 'test']\n binary = False \n undersample_majority = False\n\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\n if data_type == 'ct':\n data_r = pd.read_excel(paths[0])\n else:\n data_r = pd.read_excel(paths[1])\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\n\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \n\n if data_subtype == 'primary':\n data = data_p\n y = y_p -1\n else:\n data = data_n\n y = y_n -1\n\n if binary:\n y[y<2]=0\n y[y>0]=1\n\n y_dist = [np.sum(y==x) for x in np.unique(y)]\n print(\"Distribution of all labels: \", y_dist, \"\\n\\n\")\n\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\n\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels: \", y_dist, \"\\n\\n\")\n\n if step =='train':\n if use_syntetic_data:\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\n\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\n train_text = np.concatenate((train_text,test_text))\n y_train = np.concatenate((y_train,y_test))\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels after inserting syntetic data: \", y_dist, \"\\n\\n\")\n\n if not undersample_majority:\n data_to_use = train_text.copy()\n y_to_use = y_train.copy()\n else:\n max_label1 = 1000\n data_to_use = []\n y_to_use = []\n y1=0\n for x in range(len(y_train)):\n if y_train[x] !=1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n else:\n if y1 <max_label1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n y1+=1\n\n else:\n data_to_use = test_text.copy()\n y_to_use = y_test.copy()\n\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\n examples = []\n\n for i, tokens in tqdm(enumerate(data_to_use)):\n label = y_to_use[i]\n examples.append(\n ClassificationExample(\n id=i,\n tokens_a=basic_tokenizer.tokenize(tokens),\n tokens_b=None,\n label=label,\n )\n )\n logging.info('Number of `%s` examples: %d', step, len(examples))\n \n return examples","def load_dataset(self):\n\n train_path = os.path.join(self.dataset_path, 'images_background')\n validation_path = os.path.join(self.dataset_path, 'images_evaluation')\n\n # First let's take care of the train alphabets\n for alphabet in os.listdir(train_path):\n if alphabet[0] == '.':\n continue\n alphabet_path = os.path.join(train_path, alphabet)\n\n current_alphabet_dictionary = {}\n\n for character in os.listdir(alphabet_path):\n if character[0] == '.':\n continue\n character_path = os.path.join(alphabet_path, character)\n\n current_alphabet_dictionary[character] = os.listdir(\n character_path)\n\n self.train_dictionary[alphabet] = current_alphabet_dictionary\n\n # Now it's time for the validation alphabets\n for alphabet in os.listdir(validation_path):\n alphabet_path = os.path.join(validation_path, alphabet)\n if alphabet[0] == '.':\n continue\n\n current_alphabet_dictionary = {}\n\n for character in os.listdir(alphabet_path):\n if character[0] == '.':\n continue\n character_path = os.path.join(alphabet_path, character)\n\n current_alphabet_dictionary[character] = os.listdir(\n character_path)\n\n self.evaluation_dictionary[alphabet] = current_alphabet_dictionary","def load_data():\n print(\"PARSING TRAIN\")\n ys_train, x_train, ids_train = load_pickle_data(\"ys_train\"), load_pickle_data(\"x_train\"), load_pickle_data(\n \"ids_train\")\n if ys_train is None or x_train is None or ids_train is None:\n ys_train, x_train, ids_train = load_csv_data(\"{}/train.csv\".format(DATA_DIR))\n dump_pickle_data(ys_train, \"ys_train\")\n dump_pickle_data(x_train, \"x_train\")\n dump_pickle_data(ids_train, \"ids_train\")\n\n print(\"PARSING TEST\")\n x_test, ids_test = load_pickle_data(\"x_test\"), load_pickle_data(\"ids_test\")\n if x_test is None or ids_test is None:\n _, x_test, ids_test = load_csv_data(\"{}/test.csv\".format(DATA_DIR))\n dump_pickle_data(x_test, \"x_test\")\n dump_pickle_data(ids_test, \"ids_test\")\n\n return ys_train, x_train, ids_train, x_test, ids_test","def test(self, dataset):\n test_accuracy = 0\n test_loss = 0\n num_examples_tested = 0\n # Put model into evaluation mode\n self.model.eval()\n for num, batch in enumerate(dataset.loader):\n xs, ys = batch\n batch_size = len(xs)\n num_examples_tested += batch_size\n iloss, iaccuracy = self.model(xs, ys)\n test_loss += iloss.cpu().data.numpy().item() * batch_size\n test_accuracy += iaccuracy.cpu().data.numpy().item() * batch_size\n test_accuracy = test_accuracy / num_examples_tested\n test_loss = test_loss / num_examples_tested\n # Return accuracy and loss for this model on the test set\n return test_accuracy, test_loss","def pre_process_data(self, all_labels, all_data):\n\n # [1] Normalizes data\n all_data = self.pre_precess_manager.normalization(all_data)\n\n data_train, data_test, label_train, label_test = train_test_split(all_data, all_labels, test_size=0.1,\n shuffle=True)\n\n return data_train, data_test, label_train, label_test","def divide_data(n_reconstructions, ratio = [.8,.1,.1], test_set = True, random = False):\r\n\r\n\tassert np.sum(ratio) == 1.\r\n\r\n\tif test_set:\r\n\t\tassert len(ratio) == 3\r\n\r\n\telse:\r\n\t\tassert len(ratio) == 2\r\n\t\t\t\r\n\tif random:\r\n\t\tnp.random.seed(0)\r\n\r\n\t\tr = np.arange(n_reconstructions)\r\n\t\tnp.random.shuffle(r)\r\n\r\n\t\ti_train = r[:int(ratio[0]*n_reconstructions)]\r\n\t\ti_valid = r[int(ratio[0]*n_reconstructions):int((ratio[0]+ratio[1])*n_reconstructions)]\r\n\r\n\t\tif test_set:\r\n\t\t\ti_test = r[int((ratio[0]+ratio[1])*n_reconstructions):]\r\n\r\n\telse :\r\n\t\tr = np.arange(n_reconstructions)\r\n\t\ti_valid = r[(r+1) % int(ratio[1]*100) == 0]\r\n\r\n\t\tif test_set:\r\n\t\t\ti_test = r[(r+2) % int(ratio[2]*100) == 0]\r\n\t\t\ti_train = r[((r+1) % int(ratio[1]*100) != 0)*((r+2) % int(ratio[2]*100) != 0)]\r\n\t\t\r\n\t\telse:\r\n\t\t\ti_train = r[(r+1) % int(ratio[1]*100) != 0]\r\n\r\n\tif not(test_set):\r\n\t\ti_test = []\r\n\r\n\treturn i_train,i_valid,i_test","def make_loader(dataset, train_batch_size, validation_split=0.2):\n # number of samples in train and test set\n train_len = int(len(dataset) * (1 - validation_split))\n test_len = len(dataset) - train_len\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\n # create train_loader\n train_loader = torch.utils.data.DataLoader(\n train_set, batch_size=train_batch_size, shuffle=True,\n )\n # create test_loader\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\n return train_loader, test_loader","def load_datasets(self):\n if self.processed_extension == '.npz':\n logger.info(f'Loading sets from npz:')\n \n logger.info(f'train: {self.train_path}')\n self.train_data = sparse.load_npz(self.train_path)\n\n logger.info(f'val: {self.val_path}')\n self.val_data = sparse.load_npz(self.val_path)\n\n logger.info(f'test: {self.test_path}')\n self.test_data = sparse.load_npz(self.test_path)\n \n # Split x and y\n self.train_data = [sparse.lil_matrix(sparse.csr_matrix(self.train_data)[:,:-1]),\n sparse.lil_matrix(sparse.csr_matrix(self.train_data)[:,-1])]\n \n self.val_data = [sparse.lil_matrix(sparse.csr_matrix(self.val_data)[:,:-1]),\n sparse.lil_matrix(sparse.csr_matrix(self.val_data)[:,-1])]\n \n self.test_data = [sparse.lil_matrix(sparse.csr_matrix(self.test_data)[:,:-1]),\n sparse.lil_matrix(sparse.csr_matrix(self.test_data)[:,-1])]\n \n elif self.processed_extension == '.csv':\n logger.info(f'Loading sets from csv:')\n \n logger.info(f'train: {self.train_path}')\n self.train_data = pd.read_csv(self.train_path)\n train_cols = self.train_data.columns\n self.train_data = [self.train_data[train_cols.difference(['TARGET'])],\n self.train_data['TARGET']]\n \n logger.info(f'val: {self.val_path}')\n self.val_data = pd.read_csv(self.val_path)\n self.val_data = [self.val_data[train_cols.difference(['TARGET'])],\n self.val_data['TARGET']]\n \n logger.info(f'test: {self.test_path}')\n self.test_data = pd.read_csv(self.test_path)\n self.test_data = [self.test_data[train_cols.difference(['TARGET'])],\n self.test_data['TARGET']]\n else:\n raise AttributeError(f'Wrong extension: {self.processed_extension}')\n self.n_train = self.train_data[0].shape[0]\n self.n_val = self.val_data[0].shape[0]\n self.n_test = self.test_data[0].shape[0]\n self.input_size = self.train_data[0].shape[1]\n self.n_examples = self.n_train + self.n_val + self.n_test\n \n logger.info(f'Set sizes:')\n logger.info(f'train: {self.n_train}')\n logger.info(f'val: {self.n_val}')\n logger.info(f'test: {self.n_test}')","def create_train_test(option, transform, params, split=0.2):\r\n clip_im_dir = option.clip_im_dir\r\n matting_dir = option.matting_dir\r\n csv_path = option.csv_path\r\n \r\n print(\"create datasets\")\r\n \r\n \r\n data_df = pd.read_csv(csv_path)\r\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\r\n \r\n #separate data in training and test data (20/80)\r\n train_df, test_df = train_test_split(data_df, test_size=split)\r\n \r\n #search right Dataset class\r\n package_dir = Path(src.dataset.__file__).resolve().parent\r\n\r\n for (_, module_name, _) in iter_modules([package_dir]):\r\n # print(module_name, self.ComType)\r\n if option.dataset.lower() == module_name.lower() :\r\n modelModule = importlib.import_module(\".\"+module_name)\r\n break\r\n \r\n # train data\r\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\r\n train_loader = DataLoader(training_set, **params)\r\n \r\n \r\n #test data\r\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\r\n test_loader = DataLoader(testing_set, **params)\r\n \r\n return train_loader, test_loader","def load_data(sample_frac):\n # load snhunters data set\n data = sio.loadmat('../../../../data/3pi_20x20_skew2_signPreserveNorm.mat')\n #x = np.concatenate((data['X'], data['testX']))\n #y = np.squeeze(np.concatenate((data['y'], data['testy'])))\n x = data['X']\n y = data['y']\n # split the data into training, validation and test sets similar to MNIST\n m = data['X'].shape[0]\n m = m - int(.25*m)\n split = int(sample_frac*m)\n print(m,split)\n x_train = data['X'][:split]\n y_train = np.squeeze(data['y'])[:split]\n x_valid = data['X'][split:]\n y_valid = np.squeeze(data['y'])[split:]\n x_test = data['testX']\n y_test = np.squeeze(data['testy'])\n\n return x, y, m, split, x_train, y_train, x_valid, y_valid, x_test, y_test","def train(self):\n for data_tier in self.data_tiers:\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\n self.preprocessed_data[data_tier] = json.load(fd)\n fd.close()\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.ceil(tot*0.8))\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\n t1 = datetime.datetime.utcnow()\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\n t2 = datetime.datetime.utcnow()\n td = t2 - t1\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')","def split_data_crossvalid(data):\n X_trainfolder = []\n X_testfolder = []\n y_trainfolder = []\n y_testfolder = []\n data = data[data[:, 0].argsort()]\n number_one = np.count_nonzero(data[:, :1])\n data_one = data[np.where(data[:, 0] == 1)]\n data_zero = data[np.where(data[:, 0] == 0)]\n one_ratio = round(number_one / len(data), 1)\n one_zero_ratio = 1 - one_ratio\n batch_one = int(70 * one_ratio)\n batch_zero = int(70 * one_zero_ratio)\n batchs = len(data) // 70\n for i in range(batchs):\n test_one = data_one[i * batch_one:(i + 1) * batch_one, :]\n train_one = np.delete(data_one, test_one, axis = 0)\n test_zero = data_zero[i * batch_zero:(i + 1) * batch_zero, :]\n train_zero = np.delete(data_zero, test_zero, axis = 0)\n train_sets = np.concatenate((train_one, train_zero), axis=0)\n test_sets = np.concatenate((test_one, test_zero), axis=0)\n np.random.shuffle(train_sets)\n np.random.shuffle(test_sets)\n X_trainfolder.append(train_sets[:, 1:])\n y_trainfolder.append(train_sets[:, 0])\n X_testfolder.append(test_sets[:, 1:])\n y_testfolder.append(test_sets[:, 0])\n return X_trainfolder, y_trainfolder, X_testfolder, y_testfolder","def model(classifier, data):\n print(\"Beggining to test model\")\n train, test = cross_validation.train_test_split(data, test_size=.30)\n f,c = train[:,1:], train[:,0]\n classifier.fit(f,c,False)\n print(\"Score: \" + classifier.score(f,c))\n print(\"Finished testing model\")","def load_data_from_fold(data_path):\r\n print(\"\\nLoading data from json folder {}\".format(data_path))\r\n\r\n SAMPLES_TO_CONSIDER = 22050\r\n\r\n data = preprocess_dataset(data_path, SAMPLES_TO_CONSIDER)\r\n\r\n X = np.array(data[\"MFCCs\"])\r\n y = np.array(data[\"labels\"])\r\n print(\"Training sets loaded!\")\r\n print(\"data size :\", X.shape, \"labels size: \", y.shape)\r\n print(\"release the 'data' for memories\")\r\n del data\r\n\r\n return X, y","def crossValidate(dataset, folds):\n\tshuffle(dataset)\n\tcv_results = []\n\tprecision_recall_acc = []\n\tfoldSize = int(len(dataset)/folds)\n\tfor i in range(0,len(dataset),foldSize):\n\t\t# preparing data\n\t\tvalD = dataset[i:i+foldSize]\n\t\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\n\t\t# Training\n\t\tprint(\"*\"*60)\n\t\tprint(\"Training on data-set size \"+str(len(testD))+\" of batch \"+str(i/(foldSize)))\n\t\tclassi = trainClassifier(testD)\n\t\t# Prediction on validation data \n\t\tprint(\"Predicting on heldout data-set size...\"+str(len(valD))+\" of batch \"+str(i/(foldSize)))\n\t\ty_true = list(map(lambda t: t[1], valD))\n\t\ty_pred = predictLabels(valD,classi)\t\t\n\t\t# Performance Metrics\t\t\n\t\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\n\t\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\n\t\tacc = accuracy_score(y_true,y_pred)\n\t\tprecision_recall[-1] = acc\n\t\tprint(precision_recall)\n\t\tprecision_recall_acc.append(precision_recall)\n\tdf = pd.DataFrame(precision_recall_acc,columns = [\"Precision\",\"Recall\",\"F1 score\",\"Accuracy Score\"])\n\tprint(df)\n\tcv_results = df.mean().tolist()\n\treturn cv_results","def resplitData(self, cvRatio):\n xTrain, xTest, yTrain, yTest = cross_validation.train_test_split(\n self.x_copy, self.y_copy, test_size=cvRatio/2, random_state=None)\n\n yTrain = np.asmatrix(yTrain).reshape(len(yTrain),1)\n yTest = np.asmatrix(yTest).reshape(len(yTest),1)\n \n # assign for later plotting\n self.x = xTrain\n self.y = yTrain\n \n return xTrain, xTest, yTrain, yTest","def build_dataset(self):\n print(\"reading data of images currently , please wait......\")\n x_train, y_train, _ = get_images(self.train_directory)\n x_test, y_test, _ = get_images(self.test_directory)\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n self.x_train = x_train / 255\n self.x_test = x_test / 255\n self.y_train = utils.to_categorical(y_train, self.num_classes)\n self.y_test = utils.to_categorical(y_test, self.num_classes)","def init_train(self):\n data = self.loader.load_labelled_data(self.conf.split, 'training')\n\n # Initialise unlabelled data iterator\n num_ul = 0\n if self.conf.ul_mix > 0:\n ul_data = self.loader.load_unlabelled_data(self.conf.split, 'all')\n\n # calculate number of unlabelled images as a proportion of the labelled images\n num_ul = int(data.size() * self.conf.ul_mix)\n num_ul = num_ul if num_ul <= ul_data.size() else ul_data.size()\n log.info('Sampling %d unlabelled images out of total %d.' % (num_ul, ul_data.size()))\n ul_data.sample(num_ul)\n self.gen_X_U = data_utils.generator(self.conf.batch_size, 'overflow', ul_data.images)\n\n # Initialise labelled data iterator\n assert self.conf.l_mix >= 0\n\n # calculate number of labelled images\n num_l = int(data.size() * self.conf.l_mix)\n num_l = num_l if num_l <= data.size() else data.size()\n log.info('Using %d labelled images out of total %d.' % (num_l, data.size()))\n train_images = data.images[:num_l]\n train_masks = data.masks[:num_l]\n\n self.conf.unlabelled_image_num = num_ul\n self.conf.labelled_image_num = num_l\n self.conf.data_len = num_ul if num_ul > num_l else num_l\n self.conf.batches = int(np.ceil(self.conf.data_len / self.conf.batch_size))\n self.conf.save()\n\n self.gen_X_L = data_utils.generator(self.conf.batch_size, 'overflow', train_images, train_masks)\n\n # Initialise real masks iterator for discriminator training, using the real masks from the data CV split.\n self.other_masks = data_utils.generator(self.conf.batch_size, 'overflow', data.masks + 0)","def partition_train_valid_test_multiview2(data, classes=None, others=None, ratio=(1,1,1), rng=np.random.RandomState(1000)):\n if classes is None:\n num_samples=data[0].shape[0]\n classes=np.zeros(shape=(num_samples,),dtype=int)\n k=sum(ratio) # ratio must be a vector of integers\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\n sequence=np.arange(len(classes))\n train_ind=np.array([],dtype=int)\n valid_ind=np.array([],dtype=int)\n test_ind=np.array([],dtype=int)\n count=0\n for ki in range(k):\n if count<ratio[0]:\n train_ind=np.append(train_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\n valid_ind=np.append(valid_ind,sequence[ind==ki])\n count=count+1\n continue\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\n test_ind=np.append(test_ind,sequence[ind==ki])\n count=count+1\n continue\n num_views=len(data)\n train_set_x=[None]*num_views\n valid_set_x=[None]*num_views\n test_set_x=[None]*num_views\n for v in range(num_views):\n train_set_x[v]=data[v][train_ind,:]\n train_set_y=classes[train_ind]\n train_set_others=others[train_ind]\n valid_set_x[v]=data[v][valid_ind,:]\n valid_set_y=classes[valid_ind]\n valid_set_others=others[valid_ind]\n test_set_x[v]=data[v][test_ind,:]\n test_set_y=classes[test_ind]\n test_set_others=others[test_ind]\n return train_set_x,train_set_y,train_set_others,valid_set_x,valid_set_y,valid_set_others,test_set_x,test_set_y,test_set_others","def read_in_and_split_data(iris_data):\n iris_data = datasets.load_iris()\n data = iris_data['data']\n targets = iris_data['target']\n train_data, test_data, train_targets, test_targets = train_test_split(data, targets, test_size=0.1) \n return (train_data, test_data, train_targets, test_targets)","def learnDataset(self, data_loader):\n print(\"learning dataset\")\n\n count = 0\n for sample in data_loader:\n input_sentence = sample[\"input\"][0]\n target_sentence = sample[\"target\"][0]\n\n prev_word = None\n for word_idx in range(1, 16):\n target_word = int(target_sentence[word_idx])\n self.model_parts[word_idx - 1].populateFactors(\n input_sentence, target_word, prev_word\n )\n prev_word = target_word\n\n print(\"{}/127940\".format(count), end = \"\\r\")\n count += 1\n print(\"127940/127940\")\n\n print(\"before fixed\", list(self.model_parts[0].factors[0].d.keys())[:10])\n for i in range(15):\n self.model_parts[i].fixed()\n print(\"after fixed\", self.model_parts[0].factors[0].keys[:10])","def load_test_dataset(self):\n test_data_path = \"testdata\"\n root = Path(test_data_path)\n classes = sorted([j.name.split('/')[-1] for j in root.iterdir()])\n print(classes)\n\n transform = transforms.Compose([\n transforms.Resize(300),\n transforms.RandomHorizontalFlip(),\n transforms.CenterCrop(250),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.6071, 0.4828, 0.3934], std=[0.2845, 0.3187, 0.3240])\n ])\n\n dataset = datasets.ImageFolder(test_data_path, transform=transform)\n testloader = DataLoader(dataset, batch_size=4, shuffle=True)\n print(\"Loaded data\")\n return testloader","def load_data_and_labels(self):\n gen = image.ImageDataGenerator()\n target_size = (224,224)\n if self.preprocess:\n print('Preprocessing data...')\n if not os.path.isdir(self.pproc_dir()):\n os.mkdir(self.pproc_dir())\n \n batch_arr = []\n for ld,segment in [(self.train_dir(), 'train'),\n (self.valid_dir(), 'valid')]:\n # TODO(ness): segment = os.basename(ld)\n flowgen = gen.flow_from_directory(\n ld,\n target_size=target_size,\n shuffle=False,\n class_mode=None,\n batch_size=1)\n # Save the batches using method defined in utils.py\n data = np.concatenate([flowgen.next() for i in range(flowgen.n)])\n batches_dir = self.pproc_dir() + segment + '-bc'\n save_array(batches_dir, data)\n \n # Save the classes.\n cls_dir = self.pproc_dir() + segment + '-cl'\n save_array(cls_dir, flowgen.classes)\n \n batch_arr.append((data, flowgen.classes, flowgen.class_indices))\n \n # Set the data.\n self.training_data = batch_arr[0][0]\n self.validation_data = batch_arr[1][0]\n \n # Classes are zero-indexed and represent a category in\n # numerical form. So if the classes are 'dog' and 'cat',\n # the possible class values will be 0 and 1.\n self.trn_classes = batch_arr[0][1]\n self.val_classes = batch_arr[1][1]\n \n # Labels are the one-hot encoded (i.e. categorical)\n # version of the classes. In other words, if there are\n # 5 classes and an element belongs to class 2,\n # its label will be [0,0,1,0,0] (index 1).\n self.training_labels = to_categorical(batch_arr[0][1])\n self.validation_labels = to_categorical(batch_arr[1][1])\n \n # Class indices are dictionaries of the form\n # {'category_name': 0, 'category_name_2: 1}. They\n # make the mapping between numerical class indices and\n # a human-readable category name. They are (should be...)\n # the same for validation and training, so only load them\n # once, after sanity checking.\n self.cindices = batch_arr[0][2]\n print('Done preprocessing.')\n else:\n print('Loading data...')\n # Load the pre-saved data using methods defined in utils.py. See\n # preprocessing branch for the meaning of the data.\n self.training_data = load_array(self.pproc_dir() + 'train-bc')\n self.validation_data = load_array(self.pproc_dir() + 'valid-bc')\n self.trn_classes = load_array(self.pproc_dir() + 'train-cl')\n self.val_classes = load_array(self.pproc_dir() + 'valid-cl')\n self.training_labels = to_categorical(self.trn_classes)\n self.validation_labels = to_categorical(self.val_classes)\n \n # To get the class indices, we create the generator. It's cheap to\n # run since it doesn't actually load all the data.\n flowgen = gen.flow_from_directory(\n self.train_dir(),\n target_size=target_size,\n shuffle=False,\n class_mode=None,\n batch_size=1) \n self.cindices = flowgen.class_indices\n print('Done loading.')","def DataSplit(self, data):\n train_X,test_X,train_y,test_y=train_test_split(data[0],data[1], random_state=2)\n valid_X,valid_y=train_test_split(data[0],data[1],random_state=2,test_size=0.15)[1],train_test_split(data[0],data[1],random_state=2,test_size=0.15)[3]\n return (train_X,test_X,valid_X,train_y,test_y,valid_y)","def train(self, data_loader):\n step = 0\n train_data, valid_data = data_loader()\n\n # Allow to call `next` builtin indefinitely.\n valid_data = iter(valid_data.repeat())\n\n for epoch in range(self.hparams.num_epochs):\n for x, y in train_data:\n\n with tf.GradientTape() as g:\n train_loss = self.loss(y, self(x))\n\n grads = g.gradient(train_loss, self.trainable_variables)\n self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n\n # Validate every 1000 training steps.\n if step % 1000 == 0:\n x, y = next(valid_data)\n valid_loss = self.loss(y, self(x))\n print(\n f\"step {step} (train_loss={train_loss} valid_loss={valid_loss})\"\n )\n step += 1\n\n print(f\"epoch {epoch} finished\")\n self.save()","def get_train_val_test_datasets(\n rnd: np.random.RandomState,\n root='~/data',\n validation_ratio=0.05,\n) -> tuple:\n\n transform = transforms.Compose(\n [\n transforms.ToTensor()\n ]\n )\n\n train_set = CIFAR100(\n root=root,\n train=True,\n download=True,\n transform=transform\n )\n\n # create validation split\n if validation_ratio > 0.:\n train_set, val_set = _train_val_split(rnd=rnd, train_dataset=train_set, validation_ratio=validation_ratio)\n\n # create a transform to do pre-processing\n train_loader = DataLoader(\n train_set,\n batch_size=len(train_set),\n shuffle=False,\n )\n\n data = iter(train_loader).next()\n dim = [0, 2, 3]\n mean = data[0].mean(dim=dim).numpy()\n std = data[0].std(dim=dim).numpy()\n # end of creating a transform to do pre-processing\n\n transform = transforms.Compose(\n [\n transforms.ToTensor(),\n transforms.Normalize(\n mean, std\n ),\n ])\n\n train_set.transform = transform\n\n if validation_ratio > 0.:\n val_set.transform = transform\n else:\n val_set = None\n\n test_set = CIFAR100(\n root=root,\n train=False,\n download=True,\n transform=transform\n )\n\n return train_set, val_set, test_set"],"string":"[\n \"def train_test_loaders(dataset, validation_ratio=0.2, **kwargs):\\n dataset_size = len(dataset)\\n test_size = int(np.floor(validation_ratio * dataset_size))\\n train_size = dataset_size - test_size\\n print('TRAIN SIZE {}'.format(train_size))\\n print('TEST SIZE {}'.format(test_size))\\n train_dataset, test_dataset = random_split(dataset, (train_size, test_size),\\n generator=torch.Generator().manual_seed(RANDOM_SEED))\\n train_loader = torch.utils.data.DataLoader(train_dataset, **kwargs)\\n test_loader = torch.utils.data.DataLoader(test_dataset, **kwargs)\\n return train_loader, test_loader\",\n \"def split_data(self):\\n if not self.load_data:\\n raise AttributeError('Preprocessor has not loaded any data.')\\n \\n # 3 - Find example counts for each set\\n self.n_examples = self.data[0].shape[0]\\n self.n_train = int(self.n_examples * self.train_ratio)\\n self.n_val = int(self.n_examples * self.val_ratio)\\n self.n_test = self.n_examples - self.n_train - self.n_val\\n \\n logger.info(f'Set sizes:')\\n logger.info(f'train: {self.n_train}')\\n logger.info(f'val: {self.n_val}')\\n logger.info(f'test: {self.n_test}')\\n if self.n_test < 0:\\n raise ValueError('Train + validation ratios must bef < 1')\\n\\n # 4 - Separate data into train, test, val\\n if isinstance(self.data[0], pd.DataFrame):\\n logger.info('Dataset is in a dataframe.')\\n self.isdataframe = True\\n\\n self.train_data = [self.data[0].iloc[:self.n_train],\\n self.data[1].iloc[:self.n_train]]\\n \\n self.val_data = [self.data[0].iloc[self.n_train:self.n_val + self.n_train],\\n self.data[1].iloc[self.n_train:self.n_val + self.n_train]]\\n \\n self.test_data = [self.data[0].iloc[self.n_val + self.n_train:],\\n self.data[1].iloc[self.n_val + self.n_train:]]\\n logger.info('Data was split into train, val, test.')\\n else:\\n self.isdataframe = False\\n logger.info('Dataset is in a numpy array.')\\n \\n # If datasets are numpy array or sparse\\n self.train_data = [self.data[0][:self.n_train],\\n self.data[1][:self.n_train]]\\n \\n self.val_data = [self.data[0][self.n_train:self.n_val + self.n_train],\\n self.data[1][self.n_train:self.n_val + self.n_train]]\\n \\n self.test_data = [self.data[0][self.n_val + self.n_train:],\\n self.data[1][self.n_val + self.n_train:]]\\n logger.info('Data was split into train, val, test.')\\n \\n assert(self.n_train == self.train_data[0].shape[0])\\n assert(self.n_val == self.val_data[0].shape[0])\\n assert(self.n_test == self.test_data[0].shape[0])\\n \\n # Free memory\\n del self.data\\n \\n if self.save_sets:\\n self.save_datasets()\",\n \"def readData(path_to_dataset, train_size=0.8, validation_size=0.2):\\n data = pd.read_csv(os.path.join(path_to_dataset, 'training_set_rel3.tsv'), sep='\\\\t', encoding='ISO-8859-1')\\n # Drop columns that has null value \\n data = data.dropna(axis=1)\\n # Only take 4 columns of data from the dataset: essay_id, essay_set, essay, domain1_score\\n data = data[['essay_id', 'essay_set', 'essay', 'domain1_score']]\\n # Perform 80:20 train-test split on the training data\\n train_set, test_set = train_test_split(data, train_size=train_size, random_state=0)\\n # Split the 80% training set further into 60:20\\n training_set, validation_set = train_test_split(train_set, test_size=validation_size, random_state=0)\\n return training_set, test_set, validation_set\",\n \"def load_data_preprocess(self):\\n\\n print(\\\"Loading the dataset ...\\\")\\n # load the data\\n c_util = CarUtils()\\n train_x, train_y, test_x, test_y, classes = c_util.load_data()\\n\\n # set the image ordering\\n K.set_image_dim_ordering(\\\"th\\\")\\n\\n print(\\\"Pre-processing the dataset ...\\\")\\n # pre-process the data\\n train_x = train_x.astype('float32')\\n test_x = test_x.astype('float32')\\n\\n train_x = train_x / 255\\n test_x = test_x / 255\\n\\n print(train_x.shape[0], ' train samples')\\n print(test_x.shape[0], ' test samples')\\n\\n train_y = np_utils.to_categorical(train_y, CarsClassifierModel._nb_classes)\\n test_y = np_utils.to_categorical(test_y, CarsClassifierModel._nb_classes)\\n\\n return train_x, train_y, test_x, test_y\",\n \"def _load_data(self):\\n pickle_in = open(\\\"X_train.pickle\\\", \\\"rb\\\")\\n self.X = pickle.load(pickle_in)\\n pickle_in = open(\\\"y_train.pickle\\\", \\\"rb\\\")\\n self.Y = pickle.load(pickle_in)\\n\\n pickle_in = open(\\\"X_test.pickle\\\", \\\"rb\\\")\\n self.X_final = pickle.load(pickle_in)\\n pickle_in = open(\\\"y_test.pickle\\\", \\\"rb\\\")\\n self.Y_final = pickle.load(pickle_in)\\n\\n # Set input shape:\\n if K.image_data_format() == 'channels_first':\\n self.input_shape = (3, self.img_rows, self.img_cols)\\n else:\\n self.input_shape = (self.img_rows, self.img_cols, 3)\\n\\n self.X = self.X.astype('float32')\\n self.X /= 255\\n self.X_final = self.X_final.astype('float32')\\n self.X_final /= 255\\n print('X shape:', self.X.shape)\\n print(self.X.shape[0], 'Samples')\\n\\n num_datapoints = 3000\\n self.X = self.X[0:num_datapoints]\\n self.Y = self.Y[0:num_datapoints]\\n\\n num_datapoints = 2000\\n self.X_final = self.X_final[0:num_datapoints]\\n self.Y_final = self.Y_final[0:num_datapoints]\\n\\n self.Y_final = to_categorical(self.Y_final, self.num_classes)\\n\\n # Initialize Data\\n kfold = StratifiedKFold(n_splits=self.nFolds, shuffle=True)\\n\\n if self.b_eval_advanced:\\n # Loop through the indices the split() method returns\\n for index, (train_indices, test_indices) in enumerate(kfold.split(self.X, self.Y)):\\n if index == 0:\\n self.Y = to_categorical(self.Y, self.num_classes)\\n\\n # Generate batches from indices\\n xtrain, xtest = self.X[train_indices], self.X[test_indices]\\n ytrain, ytest = self.Y[train_indices], self.Y[test_indices]\\n\\n self.data.append(tuple([xtrain, xtest, ytrain, ytest]))\\n\\n if not self.b_eval_advanced:\\n self.Y = to_categorical(self.Y, self.num_classes)\\n\\n #print(np.asarray(self.data).shape)\\n #print(self.data)\\n print(\\\"Y_final Shape\\\", self.Y_final.shape)\",\n \"def split_data(self):\\n self.train, self.val, self.test_x, self.test_y = [], [], [], []\\n train_size = self.horizon\\n # This assumes all countries have the same length.\\n # The minus two gives space for the validation and test sets as they will overshoot.\\n k_folds = len(self.countries[0].data)//self.horizon - 2\\n for _ in range(k_folds):\\n tr, v, te_x, te_y = self.cross_validate(train_size)\\n self.train.append(tr), self.val.append(v), self.test_x.append(te_x), self.test_y.append(te_y)\\n train_size += self.horizon\",\n \"def data_split(dataset, val_ratio=0.1, test_ratio=0.1, seed=1234):\\n\\n\\t# How you grab the labels will depend on what type of Pytorch Dataset object 'dataset' is\\n\\t# (i.e. ImageFolder/DatasetFolder or not)\\n\\n\\t# For fun, check the method resolution order (MRO) of 'dataset'\\n\\tprint('Dataset object\\\\'s inheritance: ', type(dataset).__mro__)\\n\\n\\t# Determine what kind of Dataset object it is, then grab labels\\n\\t# Warning: currently this will break for anything other than an ImageFolder or CIFAR10 train set\\n\\tif isinstance(dataset, datasets.CIFAR10):\\n\\t\\tlabels = dataset.train_labels\\n\\telif isinstance(dataset, datasets.ImageFolder):\\n\\t\\tlabels = [img[1] for img in dataset.imgs]\\n\\telse:\\n\\t\\terror('Dataset not supported yet')\\n\\n\\t# Calculate class priors, (number in class)/(size of dataset)\\n\\tidcs = [i for i in range(len(dataset))]\\n\\tsamples_per_class = np.bincount(np.array(labels))\\n\\tpriors = samples_per_class/len(labels)\\n\\n\\t# Number of samples in each class for val and test set \\n\\tval_per_class = np.ceil(samples_per_class*val_ratio).astype(np.int)\\n\\ttest_per_class = np.ceil(samples_per_class*test_ratio).astype(np.int)\\n\\n\\t# Copy and shuffle the labels and corresponding indices to randomize before splitting\\n\\tshuffled_labels = list(labels)\\n\\tshuffled_idcs = list(idcs)\\n\\trandom.Random(seed).shuffle(shuffled_labels)\\n\\trandom.Random(seed).shuffle(shuffled_idcs)\\n\\n\\t# Iterate through, grabbing indices for each class to place in validation set\\n\\t# until the desired number is reached\\n\\tval_idcs = []\\n\\tval_counts = np.zeros(val_per_class.shape)\\n\\n\\tfor i, l in zip(shuffled_idcs, shuffled_labels):\\n\\t\\t# Check if validation set quota has been reached yet for this class\\n\\t\\tif val_counts[l] < val_per_class[l]:\\n\\t\\t\\tval_idcs.append(i)\\n\\t\\t\\tval_counts[l] += 1\\n\\n\\t\\t# Check if stopping point is reached\\n\\t\\tif (val_counts == val_per_class).all():\\n\\t\\t\\tbreak\\n\\n\\t# Repeat for test set\\n\\ttest_idcs = []\\n\\ttest_counts = np.zeros(test_per_class.shape)\\n\\tfor i, l in zip(shuffled_idcs, shuffled_labels):\\n\\t\\t# Check if this index is already in val set\\n\\t\\tif i in val_idcs:\\n\\t\\t\\tcontinue\\n\\n\\t\\t# Check if test set quota has been reached yet for this class\\n\\t\\tif test_counts[l] < test_per_class[l]:\\n\\t\\t\\ttest_idcs.append(i)\\n\\t\\t\\ttest_counts[l] += 1\\n\\n\\t\\t# Check if stopping point is reached\\n\\t\\tif (test_counts == test_per_class).all():\\n\\t\\t\\tbreak\\n\\n\\t# Get train indices too (all the remaining samples not in val or test)\\n\\ttrain_idcs = [j for j in idcs if j not in val_idcs+test_idcs]\\n\\n\\t# Split the data\\n\\ttrain = Subset(dataset, train_idcs)\\n\\tval = Subset(dataset, val_idcs)\\n\\ttest = Subset(dataset, test_idcs)\\n\\n\\treturn train, val, test\",\n \"def test_data_set_load(data_set):\\n data = data_set()\\n train_data, train_labels, test_data, test_labels = data.load_data()\\n\\n assert len(train_data) > 0\\n assert len(test_data) > 0\\n assert len(train_data) == len(train_labels)\\n assert len(test_data) == len(test_labels)\",\n \"def create_train_valid_set(self):\\n\\n if not self.eq_train:\\n X_train_high_level, X_valid_high_level, X_train_low_level, X_valid_low_level, train_w, valid_w, y_train, y_valid = train_test_split(self.X_train_high_level, self.X_train_low_level, self.train_weights, self.y_train,\\n train_size=0.7, test_size=0.3\\n )\\n else:\\n X_train_high_level, X_valid_high_level, X_train_low_level, X_valid_low_level, train_w, valid_w, w_train_eq, w_valid_eq, y_train, y_valid = train_test_split(self.X_train_high_level, self.X_train_low_level,\\n self.train_weights, self.train_weights_eq, self.y_train,\\n train_size=0.7, test_size=0.3\\n )\\n self.train_weights_eq = w_train_eq\\n\\n #NOTE: might need to re-equalise weights in each folds as sumW_sig != sumW_bkg anymroe!\\n self.train_weights = train_w\\n self.valid_weights = valid_w #validation weights should never be equalised weights!\\n\\n print 'creating validation dataset'\\n self.X_train_high_level = X_train_high_level\\n self.X_train_low_level = self.join_objects(X_train_low_level)\\n\\n self.X_valid_high_level = X_valid_high_level\\n self.X_valid_low_level = self.join_objects(X_valid_low_level)\\n print 'finished creating validation dataset'\\n\\n self.y_train = y_train\\n self.y_valid = y_valid\",\n \"def load_data():\\n data = gzip.open(\\\"mnist.pkl.gz\\\", \\\"rb\\\")\\n train_set, valid_set, test_set = cPickle.load(data)\\n data.close()\\n\\n # Combine validation and train folds to recreate the master 60k set.\\n new_images = numpy.concatenate((train_set[0], valid_set[0]))\\n new_labels = numpy.concatenate((train_set[1], valid_set[1]))\\n\\n train_set = (new_images, new_labels)\\n \\n return (train_set, test_set)\",\n \"def Train_data():\\n print (\\\"loading train data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\\n data_real = f['train_real'][:]\\n num, nt, ny, nx = data_real.shape\\n data_real = np.transpose(data_real, (0, 1, 3, 2))\\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\\n data_imag = f['train_imag'][:]\\n num, nt, ny, nx = data_imag.shape\\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\\n data = data_real+1j*data_imag\\n num_train = 15000\\n num_validate = 2000\\n train_data = data[0:num_train]\\n validate_data = data[num_train:num_train+num_validate]\\n\\n train_data = np.random.permutation(train_data)\\n\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end-time_start))\\n return train_data, validate_data\",\n \"def load_data(self,split='train'):\\n raise ValueError('Please implement me!')\",\n \"def load(self,train_ratio=.9,seed=123):\\n\\t\\tdata_dir = cfg.DATA_DIR\\n\\n\\t\\tif isinstance(DATASETS.get(self.data_name),dict):\\n\\t\\t\\t\\n\\t\\t\\tif len(DATASETS.get(self.data_name))==2: # Relevant only for MNIST\\n\\t\\t\\t\\ttrain_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('train'))\\n\\t\\t\\t\\ttest_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('test'))\\n\\t\\t\\t\\n\\t\\t\\telse: # Only relevant for binarized MNIST\\n\\t\\t\\t\\ttrain_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('train'))\\n\\t\\t\\t\\ttest_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('test'))\\n\\t\\t\\t\\tvalid_fpath = os.path.join(data_dir,DATASETS.get(self.data_name).get('valid'))\\n\\t\\telse:\\n\\t\\t\\tfpath = os.path.join(data_dir,DATASETS.get(self.data_name))\\n\\n\\t\\tprint(f\\\"Trying to load {self.data_name} from directory(ies):\\\")\\n\\t\\t\\n\\t\\tif self.data_name == \\\"freyfaces\\\":\\n\\t\\t\\t# Load freyfaces\\n\\t\\t\\tprint(f\\\"...from {os.path.join(data_dir,fpath)}\\\")\\n\\t\\t\\tf = open(fpath,'rb')\\n\\t\\t\\tdata = pickle.load(f,encoding='latin1')\\n\\t\\t\\tf.close()\\n\\n\\t\\t\\t# This block is directly from the VRBound repository\\n\\t\\t\\tnp.random.seed(seed)\\n\\t\\t\\tnp.random.shuffle(data)\\n\\t\\t\\tif train_ratio==1 or (0>train_ratio or 1<train_ratio):\\n\\t\\t\\t\\tprint(f\\\"Train split ratio {train_ratio} or test value is invalid!\\\")\\n\\t\\t\\t\\traise Exception\\n\\t\\t\\tnum_train = int(train_ratio* data.shape[0])\\n\\n\\t\\t\\tdata_train = data[:num_train]\\n\\t\\t\\tdata_test = data[num_train:]\\n\\t\\t\\t# End of copy\\n\\n\\t\\telif self.data_name == \\\"silhouettes\\\":\\n\\t\\t\\t# Load silhouettes data\\n\\t\\t\\tprint(f\\\"...from {os.path.join(data_dir,fpath)}\\\")\\n\\n\\t\\t\\t# These lines are also from VRBound repository\\n\\t\\t\\tdata = loadmat(fpath) \\n\\t\\t\\tdata = 1-data.get('X')\\n\\n\\t\\t\\t# This block is directly from the VRBound repository\\n\\t\\t\\tnp.random.seed(seed)\\n\\t\\t\\tnp.random.shuffle(data)\\n\\t\\t\\tif train_ratio==1 or (0>train_ratio or 1<train_ratio):\\n\\t\\t\\t\\tprint(f\\\"Train split ratio {train_ratio} or test value is invalid!\\\")\\n\\t\\t\\t\\traise Exception\\n\\t\\t\\tnum_train = int(train_ratio* data.shape[0])\\n\\n\\n\\t\\t\\tdata_train = data[:num_train]\\n\\t\\t\\tdata_test = data[num_train:]\\n\\t\\t\\t# End of copy\\n\\n\\t\\telif self.data_name == \\\"mnist\\\":\\n\\t\\t\\tprint(\\\"MNIST data is already train/test split - training ratio input ignored!\\\")\\n\\t\\t\\tprint(f\\\"...from {os.path.join(data_dir,DATASETS.get(self.data_name)['train'])}\\\")\\n\\n\\t\\t\\tdata_train, _ = MNIST(train_fpath).load_training() # We don't care about what the labels are; overwrite\\n\\t\\t\\tdata_test, _ = MNIST(test_fpath).load_testing()\\n\\n\\t\\telif self.data_name == \\\"mnist_binary\\\":\\n\\t\\t\\tprint(\\\"MNIST data is already train/test split - training ratio input ignored!\\\")\\n\\t\\t\\tprint(f\\\"...from {os.path.join(train_fpath.split('/')[-2])}\\\")\\n\\t\\t\\t# This is directly from the iwae codebase\\n\\t\\t\\tdef lines_to_np_array(lines):\\n\\t\\t\\t return np.array([[int(i) for i in line.split()] for line in lines])\\n\\t\\t\\twith open(train_fpath) as f:\\n\\t\\t\\t lines = f.readlines()\\n\\t\\t\\ttrain_data = lines_to_np_array(lines).astype('float32')\\n\\t\\t\\twith open(test_fpath) as f:\\n\\t\\t\\t lines = f.readlines()\\n\\t\\t\\tvalidation_data = lines_to_np_array(lines).astype('float32')\\n\\t\\t\\twith open(valid_fpath) as f:\\n\\t\\t\\t lines = f.readlines()\\n\\t\\t\\tdata_test = lines_to_np_array(lines).astype('float32')\\n\\n\\t\\t\\tdata_train= np.concatenate([train_data, validation_data], axis=0)\\n\\n\\t\\telif self.data_name == \\\"omniglot\\\":\\n\\t\\t\\tprint(f\\\"...from {os.path.join(data_dir,fpath)}\\\")\\n\\t\\t\\tprint(\\\"Omniglot data is already train/test split - training ratio input ignored!\\\")\\n\\n\\t\\t\\tdata = loadmat(fpath)\\n\\n\\t\\t\\t# From iwae repository\\n\\t\\t\\tdata_train = data['data'].T.astype('float32').reshape((-1, 28, 28)).reshape((-1, 28*28), order='F') \\n\\t\\t\\tdata_test = data['testdata'].T.astype('float32').reshape((-1, 28, 28)).reshape((-1, 28*28), order='F')\\n\\t\\t\\n\\t\\treturn data_train, data_test\",\n \"def load_data(opt=\\\"mnist\\\"):\\n if opt == \\\"mnist\\\":\\n train, test = tf.keras.datasets.mnist.load_data()\\n \\n x_train, y_train = train\\n x_test, y_test = test\\n \\n x_train = x_train.reshape(x_train.shape[0], 28 * 28)\\n x_test = x_test.reshape(x_test.shape[0], 28 * 28)\\n \\n y_train = y_train.astype(np.int)\\n y_test = y_test.astype(np.int)\\n for i in range(len(y_train)):\\n y_train[i] = 1 if y_train[i] % 2 == 0 else -1\\n for i in range(len(y_test)):\\n y_test[i] = 1 if y_test[i] % 2 == 0 else -1\\n\\n elif opt == \\\"covertype\\\":\\n df = pd.read_csv(\\\"covtype.data\\\", header=None)\\n x = df.iloc[:, 0:54].values\\n y = df[54].values\\n for i in range(len(y)):\\n y[i] = 1 if y[i] % 2 == 0 else -1\\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\\n \\n else:\\n logging.error(\\\"Unknown dataset!!\\\")\\n\\n logging.info(\\\"train data shape: {}\\\".format(x_train.shape))\\n logging.info(\\\"test data shape: {}\\\".format(x_test.shape))\\n return (x_train, y_train), (x_test, y_test)\",\n \"def load_dataset(split_ratio, save_root_dir):\\n # Set the processed data directories\\n train_ct, train_label_map, test_ct, test_label_map = train_test_split(split_ratio=split_ratio,\\n save_root_dir=save_root_dir)\\n\\n train_dataset = train_label_map, train_ct\\n test_dataset = test_label_map, test_ct\\n return train_dataset, test_dataset\",\n \"def __split_dataset(self):\\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)\",\n \"def train_val_split(dataset, train_val_split_ratio: float, batch_size: int):\\n num_files = len(dataset)\\n indices = list(range(num_files))\\n split = int(np.floor(train_val_split_ratio * num_files))\\n np.random.shuffle(indices)\\n train_idx, val_idx = indices[split:], indices[:split]\\n train_sampler = SubsetRandomSampler(train_idx)\\n val_sampler = SubsetRandomSampler(val_idx)\\n\\n train_dataloader = torch.utils.data.DataLoader(dataset, sampler=train_sampler, batch_size=batch_size)\\n val_dataloader = torch.utils.data.DataLoader(dataset, sampler=val_sampler, batch_size=batch_size)\\n return train_dataloader, val_dataloader\",\n \"def _split_data(self):\\n\\n # Set training data\\n self.train_data = torchvision.datasets.ImageFolder(\\n os.path.join(self.path, 'train'),\\n transform=self._transform()\\n )\\n self.classes = self.train_data.classes\\n\\n # Set validation data\\n self.val_data = torchvision.datasets.ImageFolder(\\n os.path.join(self.path, 'test'),\\n transform=self._transform(train=False)\\n )\",\n \"def data_set_maker():\\n\\n # crate a folder in your code directory and name it: \\\"files\\\". put the .npy files iside that folder\\n\\n x_all = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\\n y_all = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\\n\\n # split the data into 10% validation-set and 90% training set\\n raw_train, raw_valid, y_train, y_valid = train_test_split(x_all, y_all, test_size=0.2, random_state=43)\\n return raw_train, raw_valid, y_train, y_valid\",\n \"def loadData(self):\\n batch_size = 256\\n \\n #if self.conv_sg == True:\\n # batch_size = 1 \\n \\n download = True\\n root = self.root + self.dataset\\n if self.dataset == \\\"MNIST\\\": \\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])\\n trainset = torchvision.datasets.MNIST(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.MNIST(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR10\\\":\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465,), (0.2023, 0.1994, 0.2010,))])\\n trainset = torchvision.datasets.CIFAR10(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR10(root, train=False, download=download, transform=transform)\\n \\n if self.dataset == \\\"CIFAR100\\\":\\n transform = transforms.Compose([transforms.ToTensor()])\\n trainset = torchvision.datasets.CIFAR100(root, train=True, download=download, transform=transform)\\n testset = torchvision.datasets.CIFAR100(root, train=False, download=download, transform=transform)\\n \\n \\n trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size,\\n shuffle=False, num_workers=0, pin_memory = False)\\n \\n testloader = torch.utils.data.DataLoader(testset, batch_size= batch_size,\\n shuffle=False, num_workers=2, pin_memory = False)\\n \\n return trainloader, testloader\",\n \"def initSets(self):\\n data_frame = pd.read_csv(self.train_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n if self.test_file is None:\\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n else:\\n data_frame = pd.read_csv(self.test_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n # kfold = KFold(n_splits=3)\\n # self.train_index, self.test_index = kfold.split(features,labels)\",\n \"def load_data(self):\\n\\n self._load_train_data()\\n self._load_test_data()\",\n \"def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\\n stratified=False, random_seed=None, batch_size = 64,\\n maxsize = None, maxsize_test=None, num_workers = 0):\\n\\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\\n\\n if type(train.targets) is list or type(train.targets) is np.ndarray:\\n train.targets = torch.LongTensor(train.targets)\\n test.targets = torch.LongTensor(test.targets)\\n\\n if not hasattr(train, 'classes') or not train.classes:\\n train.classes = sorted(torch.unique(train.targets).tolist())\\n test.classes = sorted(torch.unique(train.targets).tolist())\\n\\n ### Data splitting\\n fold_idxs = {}\\n if splits is None and valid_size == 0:\\n ## Only train\\n fold_idxs['train'] = np.arange(len(train))\\n elif splits is None and valid_size > 0:\\n ## Train/Valid\\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\\n fold_idxs['train'] = train_idx\\n fold_idxs['valid'] = valid_idx\\n\\n for k, idxs in fold_idxs.items():\\n if maxsize and maxsize < len(idxs):\\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\\n\\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\\n\\n ### Create DataLoaders\\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\\n\\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\\n for k,sampler in fold_samplers.items()}\\n\\n if maxsize_test and maxsize_test < len(test):\\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\\n dataloader_args['sampler'] = sampler_test\\n else:\\n dataloader_args['shuffle'] = False\\n test_loader = dataloader.DataLoader(test, **dataloader_args)\\n fold_loaders['test'] = test_loader\\n\\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\\n fnames = '/'.join(list(fnames) + ['test'])\\n flens = '/'.join(map(str, list(flens) + [len(test)]))\\n\\n if hasattr(train, 'data'):\\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\\n print(f'Fold Sizes: {flens} ({fnames})')\\n\\n return fold_loaders, {'train': train, 'test':test}\",\n \"def data_split(data, labels, train_ratio=0.5, rand_seed=42):\\n\\n assert 0 <= train_ratio <= 1, \\\"Error: training set ratio must be between 0 and 1\\\"\\n\\n x_train, x_temp, y_train, y_temp = train_test_split(data,\\n labels,\\n train_size=train_ratio,\\n random_state=rand_seed)\\n\\n x_val, x_test, y_val, y_test = train_test_split(x_temp,\\n y_temp,\\n train_size=0.5,\\n random_state=rand_seed)\\n\\n return x_train, x_val, x_test, y_train, y_val, y_test\",\n \"def load_data(train=True):\\n#test set\\n start = time.clock()\\n\\n if train==False:\\n dp = '/home/thomas/Desktop/OttoChallenge/test.csv'\\n df = pd.read_csv(dp)\\n X = df.values.astype(np.float32)[:,1:]\\n return X\\n#train set\\n else:\\n dp = '/home/thomas/Desktop/OttoChallenge/train.csv'\\n df = pd.read_csv(dp)\\n X = df[df.columns[:-1]].values.astype(np.float32)[:,1:]\\n y = df.target\\n y =y.apply(lambda X: int(X[-1])).values\\n y = y.astype(np.int32)\\n X, y = shuffle(X, y)\\n #print(X.shape,y.shape)\\n end = time.clock()\\n print(end-start)\\n\\n return X,y\",\n \"def load_data(self,split='train'):\\n raise NotImplementedError\",\n \"def load_dataset(data_dir, img_size):\\n global input_set\\n global test_set\\n\\n imgs = []\\n img_files = os.listdir(data_dir)\\n for img in img_files:\\n # try:\\n tmp = scipy.misc.imread(data_dir + \\\"/\\\" + img)\\n x, y, z = tmp.shape # shape : width * length * chanel\\n coords_x = int(x / img_size) # 坐标\\n coords_y = int(y / img_size) #\\n coords = [(q, r) for q in range(coords_x) for r in range(coords_y)] # 列表 x * y\\n for coord in coords:\\n imgs.append((data_dir + \\\"/\\\" + img, coord)) # 为列表添加文件目录\\n # except BaseException:\\n # print(\\\"oops\\\")\\n test_size = min(10, int(len(imgs) * 0.2))\\n random.shuffle(imgs)\\n test_set = imgs[:test_size]\\n train_set_X = imgs[test_size:][:200]\\n train_set = imgs[test_size:][200:400]\\n return\",\n \"def train_and_test(self, data):\\n\\n np.random.shuffle(data)\\n datalist = self.unpack_data(data)\\n\\n logger.info('[*] 75-25 partition of datasets ...')\\n\\n markline1 = math.floor(0.75*(len(datalist['features'])))\\n markline2 = math.floor(0.75*len(datalist['labels']))\\n\\n train_features = datalist['features'][:(markline1)]\\n test_features = datalist['features'][(markline1):]\\n \\n train_labels = datalist['labels'][:(markline2)]\\n test_labels = datalist['labels'][(markline2):]\\n\\n logger.info('[*] Training started with 75% Dataset ...')\\n\\n self.knn_model.fit(train_features, train_labels)\\n\\n logger.info('[*] Testing started with 25% Dataset ...')\\n print('\\\\n/---------------Accuracy----------------/') \\n \\n accuracy = self.knn_model.score(train_features, train_labels)\\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\\n\\n if accuracy < 0.40:\\n logger.warning('[-.-!] Thanks for tryin\\\\' but this machine ain\\\\'t learning.')\\n\\n return True\",\n \"def load_dataset(self):\\n # Get all the files in the directory\\n file_list = self.get_file_list()\\n\\n # Concatenate the data corresponding to a list of files\\n data = self.concatenate_file_data(file_list)\\n\\n # Shuffle the data and create the training and the validation datasets\\n data = self.shuffle_data_dictionary(data)\\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)\",\n \"def load_train_data():\\r\\n X_train = np.load('data/train/X_train.npy')\\r\\n scaling_train = np.load('data/train/scaling_train.npy')\\r\\n ids_train = np.load('data/train/ids_train.npy')\\r\\n y_train = np.load('data/train/y_train.npy')\\r\\n\\r\\n seed = np.random.randint(1, 10e6)\\r\\n np.random.seed(seed)\\r\\n np.random.shuffle(X_train)\\r\\n np.random.seed(seed)\\r\\n np.random.shuffle(scaling_train)\\r\\n np.random.seed(seed)\\r\\n np.random.shuffle(ids_train)\\r\\n np.random.seed(seed)\\r\\n np.random.shuffle(y_train)\\r\\n\\r\\n return X_train, scaling_train, ids_train, y_train\",\n \"def partition_train_valid_test2(data, classes, others, ratio=(1,1,1), rng=np.random.RandomState(1000)):\\n k=sum(ratio) # ratio must be a vector of integers\\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\\n sequence=np.arange(len(classes))\\n train_ind=np.array([],dtype=int)\\n valid_ind=np.array([],dtype=int)\\n test_ind=np.array([],dtype=int)\\n count=0\\n for ki in range(k):\\n if count<ratio[0]:\\n train_ind=np.append(train_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\\n valid_ind=np.append(valid_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\\n test_ind=np.append(test_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n train_set_x=data[train_ind]\\n train_set_y=classes[train_ind]\\n if others is not None:\\n train_set_others=others[train_ind]\\n else:\\n train_set_others=None\\n valid_set_x=data[valid_ind]\\n valid_set_y=classes[valid_ind]\\n if others is not None:\\n valid_set_others=others[valid_ind]\\n else:\\n valid_set_others=None\\n test_set_x=data[test_ind]\\n test_set_y=classes[test_ind]\\n if others is not None:\\n test_set_others=others[test_ind]\\n else:\\n test_set_others=None\\n \\n return train_set_x,train_set_y,train_set_others,valid_set_x,valid_set_y,valid_set_others,test_set_x,test_set_y,test_set_others\",\n \"def partition_train_valid_test(data, classes, ratio=(1,1,1), rng=np.random.RandomState(1000)):\\n k=sum(ratio) # ratio must be a vector of integers\\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\\n sequence=np.arange(len(classes))\\n train_ind=np.array([],dtype=int)\\n valid_ind=np.array([],dtype=int)\\n test_ind=np.array([],dtype=int)\\n count=0\\n for ki in range(k):\\n if count<ratio[0]:\\n train_ind=np.append(train_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\\n valid_ind=np.append(valid_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\\n test_ind=np.append(test_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n train_set_x=data[train_ind]\\n train_set_y=classes[train_ind]\\n valid_set_x=data[valid_ind]\\n valid_set_y=classes[valid_ind]\\n test_set_x=data[test_ind]\\n test_set_y=classes[test_ind]\\n return train_set_x,train_set_y,valid_set_x,valid_set_y,test_set_x,test_set_y\",\n \"def _load_data(self):\\n if self._name in BALANCE_DATASET:\\n _loader = dataset_loaders[self._name]\\n xnp, y = _loader()\\n\\n # Train - Test split\\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\\n train_idx, test_idx = next(gen)\\n\\n # Train data.\\n self.xnp_tr = xnp[train_idx]\\n self.y_tr = y[train_idx]\\n # Test data.\\n self.xnp_ts = xnp[test_idx]\\n self.y_ts = y[test_idx]\\n\\n else:\\n _loader = dataset_loaders[self._name]\\n xnp, xp, y = _loader()\\n # self.xnp, self.xp, self.y = _loader()\\n\\n # Train - Test split\\n gen = ShuffleSplit(n_splits=1, random_state=42, test_size=self._test_size).split(xnp)\\n train_idx, test_idx = next(gen)\\n\\n # Train data.\\n self.xnp_tr = xnp[train_idx]\\n self.xp_tr = xp[train_idx]\\n self.y_tr = y[train_idx]\\n # Test data.\\n self.xnp_ts = xnp[test_idx]\\n self.xp_ts = xp[test_idx]\\n self.y_ts = y[test_idx]\",\n \"def load_occupancy_dataset(trainsize=500, testsize=1000):\\n filename = 'datasets/numericsequence.csv'\\n dataset = loadcsv(filename)\\n trainset, testset = splitdataset(dataset, trainsize, testsize)\\n return trainset, testset\",\n \"def prepare_dataset(data_path, test_size=0.2, validation_size=0.2):\\r\\n\\r\\n # load dataset\\r\\n if data_path.endswith('json'):\\r\\n X, y = load_data_from_json(data_path)\\r\\n else:\\r\\n X, y = load_data_from_fold(data_path)\\r\\n # create train, validation, test split\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size)\\r\\n X_train, X_validation, y_train, y_validation = train_test_split(X_train, y_train, test_size=validation_size)\\r\\n\\r\\n # add an axis to nd array\\r\\n X_train = X_train[..., np.newaxis]\\r\\n X_test = X_test[..., np.newaxis]\\r\\n X_validation = X_validation[..., np.newaxis]\\r\\n\\r\\n return X_train, y_train, X_validation, y_validation, X_test, y_test\",\n \"def load_data(self):\\n with open('data/fordTrain.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n train = [x for i, x in enumerate(data) if i > 0] \\n # Extract features and target variable separately\\n trainx = [x[3:] for x in train]\\n trainy = [x[2] for x in train]\\n\\n with open('data/fordTest.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \\n\\n with open('data/Solution.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testy = [x[2] for i, x in enumerate(data) if i > 0] \\n\\n # Extract features and target variable, convert to numpy array\\n trainx = np.asarray(trainx, dtype=np.float32)\\n trainy = np.asarray(trainy, dtype=np.int8)\\n testx = np.asarray(testx, dtype=np.float32)\\n testy = np.asarray(testy, dtype=np.int8)\\n\\n # Return training and test sets\\n trainSet = Dataset(trainx, trainy)\\n testSet = Dataset(testx, testy)\\n return trainSet, testSet\",\n \"def load_data(args):\\n data_df = pd.read_csv(os.path.join(args.data_dir, 'driving_log.csv'))\\n\\n X = data_df[['center', 'left', 'right']].values\\n y = data_df['steering'].values\\n\\n X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=args.test_size, random_state=0)\\n\\n return X_train, X_valid, y_train, y_valid\",\n \"def _load_train_data(self):\\n\\n self.train_loader = data.Train_loader(self.N_max, self.n_per_conn,\\n self.data_path, self.device)\\n self.train_loader.load_data()\\n\\n # load mean and std\\n scc_mean_std = np.loadtxt(\\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\\n self.mean = torch.Tensor(scc_mean_std[0])\\n self.std = torch.Tensor(scc_mean_std[1])\",\n \"def load_data(self):\\n sets = ['train', 'val']\\n images = []\\n labels = []\\n self.labels_dic = {}\\n file = open(self.path + 'wnids.txt')\\n train_labels = file.read().split()\\n if self.train:\\n for fn in range(self.num_classes):\\n f = train_labels[fn]\\n for i in os.listdir(self.path + 'train/' + f + '/images/'):\\n images.append(Image.open(self.path + 'train/' + f + '/images/' + i))\\n labels.append(f)\\n #image label n link to folder names of TinyImageNet\\n self.labels_dic[f] = fn\\n\\n else:\\n for fn in range(self.num_classes):\\n f = train_labels[fn]\\n self.labels_dic[f] = fn\\n file_val = open(self.path + 'val/val_annotations.txt')\\n val_labels = file_val.read().split('\\\\n')\\n for im in val_labels:\\n im_data = im.split(\\\"\\t\\\")[:2]\\n if len(im_data) < 2:\\n continue\\n if im_data[1] in self.labels_dic:\\n images.append(Image.open(self.path + 'val/images/' + im_data[0]))\\n labels.append(im_data[1])\\n\\n self.images = images\\n self.labels = labels\",\n \"def load_data():\\n directories=[\\\"./track1/\\\",\\n \\\"./track1_recovery/\\\",\\n \\\"./track2/\\\",\\n \\\"./track1_reverse/\\\",\\n \\\"./track2_reverse/\\\",#Additional data for model built on top of lenet.h5\\n \\\"./track2_recovery/\\\",#Additions data for model built on top of lenet.h5\\n ]\\n lines=[]\\n for directory in directories:\\n with open(directory+\\\"driving_log.csv\\\") as csvfile:\\n reader=csv.reader(csvfile)\\n for line in reader:\\n lines.append(line)\\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\\n return train_samples, validation_samples\",\n \"def load_data(data_dir, split=1.0):\\n n = 123 * 41\\n positive_examples = glob.glob(data_dir + '/positive_set/*.png')\\n negative_examples = glob.glob(data_dir + '/negative_set/*.png')\\n x = np.zeros((n, len(positive_examples) + len(negative_examples)))\\n for k in range(len(positive_examples)):\\n x[:,k] = np.reshape(img.imread(positive_examples[k]), (n,))\\n for k in range(len(negative_examples)):\\n x[:, k+len(positive_examples)] = np.reshape(img.imread(negative_examples[k]), (n,))\\n y = np.concatenate((np.ones((1,len(positive_examples))), np.zeros((1,len(negative_examples)))), axis=1)\\n arr = np.concatenate((x,y), axis=0)\\n part_train = int(math.floor(split * arr.shape[1]))\\n np.random.shuffle(arr.T)\\n x_train = arr[0:-1,0:part_train]\\n y_train = arr[-1,0:part_train]\\n x_test = arr[0:-1,part_train:]\\n y_test = arr[-1,part_train:]\\n if split == 1.0:\\n return (x_train.T, y_train.T)\\n else:\\n return (x_train.T, y_train.T),(x_test.T,y_test.T)\",\n \"def load(train_file, test_file):\\n print('\\\\nLoad the raw training and test set data...')\\n y_train, tx_train, ids_train = load_csv_data(train_file)\\n y_test, tx_test, ids_test = load_csv_data(test_file)\\n print('\\\\n... finished.')\\n return y_train, tx_train, ids_train, y_test, tx_test, ids_test\",\n \"def load_data():\\r\\n train_dataset = h5py.File('train_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\r\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\r\\n\\r\\n test_dataset = h5py.File('test_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\r\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\r\\n\\r\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\r\\n \\r\\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\r\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\r\\n \\r\\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def _load_test_data(self):\\n\\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\\n self.data_path, self.device)\\n\\n self.test_loader.load_data()\\n\\n # load mean and std from train\\n scc_mean_std = np.loadtxt(\\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\\n self.mean = torch.Tensor(scc_mean_std[0])\\n self.std = torch.Tensor(scc_mean_std[1])\",\n \"def trainAndCalculate(self):\\n f = open(\\\"congressional_voting_dataset.csv\\\")\\n data = np.genfromtxt(fname = f, delimiter=',', dtype=str, encoding=None)\\n X = data[:, :-1]\\n y = data[:, -1]\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)\\n self.svclassifier.fit(X_train, y_train)\",\n \"def load_data(n_folds=10):\\n\\n sss = sssplit(n_splits=n_folds, test_size=.1, random_state=np.random.RandomState(830452))\\n X, y = get_transformed_data()\\n (X_train, y_train), (X_test, y_test) = ([],[]),([],[])\\n\\n for train_idx, test_idx in sss.split(X, y):\\n X_train.append(X[train_idx])\\n y_train.append(y[train_idx])\\n X_test.append(X[test_idx])\\n y_test.append(y[test_idx])\\n\\n return (X_train, y_train), (X_test, y_test)\",\n \"def run_train_test_split():\\n # Load all documents\\n conn = sq.connect(config.DB_FILE)\\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\\n\\n # Identify unique review IDs\\n review_ids = documents['review_id'].unique()\\n\\n # Set seed for random sampling\\n np.random.seed(2)\\n\\n # List of Reviews in the partial data set and full data set\\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\\n full_set = list(review_ids.copy())\\n\\n # Load array (X) and labels (Y) of all documents\\n with (open(config.DOC_TERM_MATRIX, \\\"rb\\\")) as openfile:\\n X = pickle.load(openfile)\\n\\n y = documents['included']\\n\\n # Train-test split of the partial dataset\\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\\n\\n # Train-test split of the full dataset\\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)\",\n \"def cross_validation_datasets(self, fold):\\n if fold > len(self): fold = len(self) / 2\\n stratified = self.stratified_bunches(fold)\\n datasets = []\\n for index in range(len(stratified)):\\n gold = GoldInstances(training_as_gold(stratified[index]))\\n rest = flatten(stratified[:index]) + flatten(stratified[index + 1:])\\n training = TrainingInstances(rest)\\n datasets.append((training, gold))\\n return datasets\",\n \"def load_data(train_path, test_path):\\n\\n train_data = pd.read_csv(train_path)\\n test_data = pd.read_csv(test_path)\\n\\n print(\\\"number of training examples = \\\" + str(train_data.shape[0]))\\n print(\\\"number of test examples = \\\" + str(test_data.shape[0]))\\n print(\\\"train shape: \\\" + str(train_data.shape))\\n print(\\\"test shape: \\\" + str(test_data.shape))\\n\\n return train_data, test_data\",\n \"def load_data(train_path, test_path):\\n\\n train_data = pd.read_csv(train_path)\\n test_data = pd.read_csv(test_path)\\n\\n print(\\\"number of training examples = \\\" + str(train_data.shape[0]))\\n print(\\\"number of test examples = \\\" + str(test_data.shape[0]))\\n print(\\\"train shape: \\\" + str(train_data.shape))\\n print(\\\"test shape: \\\" + str(test_data.shape))\\n\\n return train_data, test_data\",\n \"def split_train_val(self,ratio=.1):\\n lim = int(np.ceil(len(self.train) * ratio))\\n order = list(range(len(self.train)))\\n np.random.shuffle(order)\\n self.train_train = self.train.ix[order[lim:]]\\n self.train_val = self.train.ix[order[:lim]]\\n log(\\\"Split data into training/val: {} -> {} {}\\\".format(\\n len(self.train),len(self.train_train),lim))\",\n \"def load_train_test_transactions(train_size=0.7):\\n X, y = features_target_split()\\n X_train, X_test, y_train, y_test = train_test_split(X,y,train_size=train_size, random_state=7)\\n print('\\\\nTraining and testing data creation successful\\\\n')\\n return X_train, X_test, y_train,y_test\",\n \"def train_model(self, data_loader):\\n train_squared_loss = 0\\n correct = 0\\n total = 0\\n\\n self.train()\\n for user, item, rating in data_loader:\\n self.optimizer.zero_grad()\\n\\n forward = self(user, item)\\n predicted = self._prob_to_class(forward)\\n loss = self.loss(forward, rating)\\n\\n train_squared_loss += loss.item() * len(user)\\n total += predicted.numel()\\n correct += (predicted == rating.view(-1)).sum().item()\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n mean_loss = train_squared_loss / total\\n\\n return mean_loss, f\\\"{(100 * correct / total):.2f}\\\"\",\n \"def _load_data(self, X, y):\\n self.Xtrain = X\\n\\n # y if categories, needs to be transformed to number before fit\\n self.le = LabelEncoder()\\n self.ytrain = self.le.fit_transform(y)\",\n \"def load_data():\\n # Load data\\n X_train = pd.read_csv(\\n \\\"data/trimmed_merged_no_track_id_or_session_id.csv\\\"\\n ) # load data from csv\\n\\n drop_columns = [\\\"mode\\\"] # drop unimportant columns\\n X_train.drop(labels=drop_columns, axis=1, inplace=True)\\n\\n y_train = X_train[\\\"skip\\\"]\\n X_train.drop(labels=\\\"skip\\\", axis=1, inplace=True) # ground truth from train_data\\n\\n # split data 60% train, 20% validation, 20% test\\n X_train, X_val, y_train, y_val = train_test_split(\\n X_train, y_train, test_size=0.2, random_state=1\\n )\\n X_train, X_test, y_train, y_test = train_test_split(\\n X_train, y_train, test_size=0.25, random_state=1\\n )\\n\\n print(\\\"X_train:\\\", len(X_train))\\n print(\\\"y_train:\\\", len(y_train))\\n print(\\\"X_val:\\\", len(X_val))\\n print(\\\"y_val:\\\", len(y_val))\\n print(\\\"X_test:\\\", len(X_test))\\n print(\\\"y_test:\\\", len(y_test))\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def load_data(self):\\n print('Loading {} dataset'.format(self.split))\\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\\n with open(data_split_path,'r') as f:\\n reader = csv.reader(f, delimiter=',')\\n data_classes = {}\\n for i,row in enumerate(reader):\\n if i==0:\\n continue\\n data_classes[row[1]] = 1\\n data_classes = data_classes.keys()\\n print(data_classes)\\n\\n n_classes = len(data_classes)\\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if self.n_unlabel>0:\\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n dataset_u = []\\n\\n for i, cls in enumerate(data_classes):\\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\\n for j, im_file in enumerate(im_files):\\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \\n np.float32, copy=False)\\n if j<self.n_label:\\n dataset_l[i, j] = im\\n else:\\n dataset_u[i,j-self.n_label] = im\\n print('labeled data:', np.shape(dataset_l))\\n print('unlabeled data:', np.shape(dataset_u))\\n \\n self.dataset_l = dataset_l\\n self.dataset_u = dataset_u\\n self.n_classes = n_classes\",\n \"def train_with_loader(self, data, validating_data=None, scheduler=None, epochs=1):\\n print('Training...')\\n for epoch in range(epochs):\\n self.train()\\n for train_in, train_out in data:\\n self.compute_loss(train_in, train_out, is_guess=False, training=True)\\n self.eval()\\n if validating_data:\\n with torch.no_grad():\\n valid_loss = self.compute_loss_loader(validating_data).item()\\n print('Average validation error at step ',epoch+1,': ', valid_loss)\\n if scheduler and valid_loss:\\n scheduler.step()\",\n \"def load_data(input_file, test_size, random_seed ):\\n ratings = np.genfromtxt(input_file, delimiter=',')\\n #ratings = ratings[:200,:]\\n train_masks = np.zeros_like(ratings)\\n test_masks = np.zeros_like(ratings)\\n pairs = list()\\n for i in range(ratings.shape[0]):\\n for j in range(ratings.shape[1]):\\n pairs.append((i,j))\\n train, test = train_test_split(pairs ,test_size = test_size, random_state= random_seed)\\n for user,item in train:\\n train_masks[user, item]= 1\\n for user,book in test:\\n test_masks[user, item]= 1 \\n return ratings, train_masks, test_masks\",\n \"def split_data(data,param):\\n all_x = data[['GDP_scaled','CLPRB_scaled','EMFDB_scaled','ENPRP_scaled','NGMPB_scaled','PAPRB_scaled','PCP_scaled','ZNDX_scaled','OP_scaled', 'OP2_scaled']][:55]\\n all_y = data[[param]][:55]\\n return cross_validation.train_test_split(all_x, all_y, test_size=0.2, random_state=0)\",\n \"def get_training_and_testing_sets(data, Y):\\r\\n data = pd.concat([data, Y], axis=1)\\r\\n x,y=data.shape\\r\\n train_X_sub1=data[0:x//6]\\r\\n dev_X_sub1 = data[x//6:x//6 + x//12]\\r\\n test_X_sub1 = data[x//6 + x//12:x//3]\\r\\n\\r\\n train_X_sub2 = data[x//3:x//3+x//6]\\r\\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\\r\\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\\r\\n\\r\\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\\r\\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\\r\\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\\r\\n\\r\\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\\r\\n train_X =train_X.append(train_X_sub3,ignore_index = True)\\r\\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\\r\\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\\r\\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\\r\\n test_X = test_X.append(test_X_sub3,ignore_index = True)\\r\\n\\r\\n\\r\\n train_X = util.shuffle(train_X)\\r\\n train_X = train_X.reset_index(drop=True)\\r\\n\\r\\n dev_X = util.shuffle(dev_X)\\r\\n dev_X = dev_X.reset_index(drop=True)\\r\\n\\r\\n test_X = util.shuffle(test_X)\\r\\n test_X = test_X.reset_index(drop=True)\\r\\n\\r\\n train_X_final=train_X\\r\\n dev_X_final = dev_X\\r\\n test_X_final = test_X\\r\\n x, y = train_X_final.shape\\r\\n train_X = train_X_final.iloc[:, 0:y - 1]\\r\\n train_Y = train_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = test_X_final.shape\\r\\n test_X = test_X_final.iloc[:, 0:y - 1]\\r\\n test_Y = test_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = dev_X_final.shape\\r\\n dev_X = dev_X_final.iloc[:, 0:y - 1]\\r\\n dev_Y = dev_X_final.iloc[:, y - 1]\\r\\n\\r\\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y\",\n \"def load_data(data_path):\\n headers = ['center', 'left', 'right','steering','throttle','brake','speed']\\n data = pd.read_csv(data_path + '/driving_log.csv', names = headers)\\n \\n # Use SciKit not keras splitting so it randomly selects validation set\\n d_train, d_valid = train_test_split(data, test_size=0.2, random_state=42)\\n\\n return d_train, d_valid\",\n \"def fit(self, data_loader):\\n train_data, valid_data = data_loader.load()\\n\\n self.compile(self.optimizer, self.loss)\\n super().fit(\\n x=train_data,\\n validation_data=valid_data,\\n validation_steps=32, # validate 32 batches at a time\\n validation_freq=1, # validate every 1 epoch\\n epochs=self.hparams.num_epochs,\\n shuffle=False, # dataset instances already handle shuffling\\n )\\n self.save()\",\n \"def load_data(train_data,limit=0, split=0.8):\\n # Partition off part of the train data for evaluation\\n #random.shuffle(train_data)\\n train_data = train_data[-limit:]\\n Y,X = train_data[\\\"type\\\"], train_data[\\\"posts\\\"]\\n y = []\\n for y_ in Y:\\n if y_[0] == 'I' : INTROVERTED = True\\n else: INTROVERTED = False\\n if y_[1] == 'N' : INTUTIVE= True\\n else: INTUTIVE= False\\n if y_[2] == 'T' : THINKING= True\\n else: THINKING= False\\n if y_[3] == 'J' : JUDGEMENTAL= True\\n else: JUDGEMENTAL= False\\n y.append({'INTROVERTED':INTROVERTED,\\\"INTUTIVE\\\":INTUTIVE,\\\"THINKING\\\":THINKING,\\\"JUDGEMENTAL\\\":JUDGEMENTAL})\\n\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split, random_state=42)\\n return (X_train, y_train), (X_test, y_test)\",\n \"def _load_training_and_test_sets(normalize):\\n class_labels = []\\n test_labels = []\\n norm = None\\n if normalize == True:\\n norm = loading.get_normalize_vector()\\n\\n for i in range(0, 10):\\n [training, test] = loading.load_number_set(i, 0.7, norm_vector=norm)\\n labels = [str(i)] * training.shape[0]\\n tlabels = [str(i)] * test.shape[0]\\n if i == 0:\\n train_points = training\\n test_points = test\\n else:\\n train_points = np.concatenate((train_points, training), axis = 0)\\n test_points = np.concatenate((test_points, test), axis = 0)\\n class_labels.extend(labels)\\n test_labels.extend(tlabels)\\n\\n return train_points, test_points, class_labels, test_labels\",\n \"def cross_validation(self, stock_data):\\n\\n self.X_train, self.X_test, self.y_train, self.y_test = cross_validation.train_test_split(stock_data['X'], stock_data['Y'], test_size=0.2, train_size=0.8, random_state=3)\",\n \"def train_validation_split(data_path, train_path, validation_path, train_samples, validation_samples, sample_type='jpg'):\\n remove_files_in_folder(train_path)\\n remove_files_in_folder(validation_path)\\n \\n print(f\\\"Doing train/validation split. {len(train_samples)} training samples, {len(validation_samples)} validation samples.\\\")\\n for fi in tqdm(os.listdir(data_path)):\\n if fi.endswith(sample_type):\\n obj = fi.split('.')\\n try:\\n ind = int(obj[0])\\n except:\\n continue\\n if ind in train_samples:\\n copyfile(os.path.join(data_path, fi), os.path.join(train_path, fi))\\n \\n if ind in validation_samples:\\n copyfile(os.path.join(data_path, fi), os.path.join(validation_path, fi))\",\n \"def load_data(filename, split = 0.9):\\n (black, white, player, move, ko) = read_file(filename)\\n dataset = zip(black, white, player, move, ko)\\n train_data = dataset[:int(math.ceil(split*len(dataset)))]\\n test_data = dataset[int(math.ceil(split*len(dataset))):]\\n return train_data, test_data\",\n \"def get_data_loaders(data, batch_size, ratio=0.8, num_workers=1):\\n train_size = int(len(data) * ratio)\\n val_size = len(data) - train_size\\n train_set, val_set = random_split(data, [train_size, val_size])\\n data_train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n data_val_loader = DataLoader(val_set, batch_size=batch_size, num_workers=num_workers, shuffle=True)\\n return data_train_loader, data_val_loader\",\n \"def load_dataset():\\n\\n\\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\\n collate_fn=PadCollate())\\n\\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\\n collate_fn=PadCollate())\\n\\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\\n\\n return train_dd_loader, train_dataloader, test_dataloader\",\n \"def train_val_split(self):\\n idx = np.arange(self.num_data)\\n np.random.shuffle(idx)\\n val_num = int(self.ratio * self.num_data)\\n dev_num = int(self.dev_ratio * self.num_data)\\n self.num_train = self.num_data - val_num\\n\\n self.val_data = self.data[idx[:val_num]]\\n self.val_label = self.label[idx[:val_num]]\\n \\n self.train_data = self.data[idx[val_num:]]\\n self.train_label = self.label[idx[val_num:]]\\n\\n self.dev_data = self.data[idx[:dev_num]]\\n self.dev_label = self.label[idx[:dev_num]]\",\n \"def train(self, data):\\n pass\",\n \"def test__load_training_set():\\n classifier = classifier_module.Classifier(None)\\n set = classifier._load_training_set('test')\\n for i in range(0, 5):\\n signal_list = set[i]\\n assert signal_list[0].get_x() == 1.0 + i * 0.028\\n assert signal_list[0].get_y() == 1.00 - i * i * 0.20 * 0.30\\n\\n assert signal_list[1].get_x() == 2.0 - i * 0.011\\n assert signal_list[1].get_y() == 2.00 - i * 0.020\",\n \"def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\\n distribute_training=False):\\n train_set = np.array(train_set)\\n test_set = np.array(test_set)\\n\\n print(\\\"The shape of training set before dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set before dimension reduction is {0}\\\".format(test_set.shape))\\n print('Use distribute training ? >> {0}'.format(distribute_training))\\n reg = linear_model.BayesianRidge()\\n\\n if dimension_reduce:\\n pca = PCA(n_components=128)\\n train_set = pca.fit_transform(train_set)\\n test_set = pca.fit_transform(test_set)\\n\\n print(\\\"The shape of training set after dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set after dimension reduction is {0}\\\".format(test_set.shape))\\n\\n if not distribute_training:\\n reg.fit(train_set, train_label)\\n else:\\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\\n train_label), da.array(test_label)\\n reg.fit(train_set, train_label)\\n\\n predicted_label = reg.predict(test_set)\\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\\n print('The regression model has been persisted...')\\n\\n mkdirs_if_not_exist('./result')\\n\\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\\n\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/%s.csv' % data_name, index=False)\\n print('The result csv file has been generated...')\",\n \"def train(self, training_data):\\n pass\",\n \"def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\\n assert step in ['train', 'test']\\n binary = False \\n undersample_majority = False\\n\\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\\n if data_type == 'ct':\\n data_r = pd.read_excel(paths[0])\\n else:\\n data_r = pd.read_excel(paths[1])\\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\\n\\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \\n\\n if data_subtype == 'primary':\\n data = data_p\\n y = y_p -1\\n else:\\n data = data_n\\n y = y_n -1\\n\\n if binary:\\n y[y<2]=0\\n y[y>0]=1\\n\\n y_dist = [np.sum(y==x) for x in np.unique(y)]\\n print(\\\"Distribution of all labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\\n\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if step =='train':\\n if use_syntetic_data:\\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\\n\\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\\n train_text = np.concatenate((train_text,test_text))\\n y_train = np.concatenate((y_train,y_test))\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels after inserting syntetic data: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if not undersample_majority:\\n data_to_use = train_text.copy()\\n y_to_use = y_train.copy()\\n else:\\n max_label1 = 1000\\n data_to_use = []\\n y_to_use = []\\n y1=0\\n for x in range(len(y_train)):\\n if y_train[x] !=1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n else:\\n if y1 <max_label1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n y1+=1\\n\\n else:\\n data_to_use = test_text.copy()\\n y_to_use = y_test.copy()\\n\\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\\n examples = []\\n\\n for i, tokens in tqdm(enumerate(data_to_use)):\\n label = y_to_use[i]\\n examples.append(\\n ClassificationExample(\\n id=i,\\n tokens_a=basic_tokenizer.tokenize(tokens),\\n tokens_b=None,\\n label=label,\\n )\\n )\\n logging.info('Number of `%s` examples: %d', step, len(examples))\\n \\n return examples\",\n \"def load_dataset(self):\\n\\n train_path = os.path.join(self.dataset_path, 'images_background')\\n validation_path = os.path.join(self.dataset_path, 'images_evaluation')\\n\\n # First let's take care of the train alphabets\\n for alphabet in os.listdir(train_path):\\n if alphabet[0] == '.':\\n continue\\n alphabet_path = os.path.join(train_path, alphabet)\\n\\n current_alphabet_dictionary = {}\\n\\n for character in os.listdir(alphabet_path):\\n if character[0] == '.':\\n continue\\n character_path = os.path.join(alphabet_path, character)\\n\\n current_alphabet_dictionary[character] = os.listdir(\\n character_path)\\n\\n self.train_dictionary[alphabet] = current_alphabet_dictionary\\n\\n # Now it's time for the validation alphabets\\n for alphabet in os.listdir(validation_path):\\n alphabet_path = os.path.join(validation_path, alphabet)\\n if alphabet[0] == '.':\\n continue\\n\\n current_alphabet_dictionary = {}\\n\\n for character in os.listdir(alphabet_path):\\n if character[0] == '.':\\n continue\\n character_path = os.path.join(alphabet_path, character)\\n\\n current_alphabet_dictionary[character] = os.listdir(\\n character_path)\\n\\n self.evaluation_dictionary[alphabet] = current_alphabet_dictionary\",\n \"def load_data():\\n print(\\\"PARSING TRAIN\\\")\\n ys_train, x_train, ids_train = load_pickle_data(\\\"ys_train\\\"), load_pickle_data(\\\"x_train\\\"), load_pickle_data(\\n \\\"ids_train\\\")\\n if ys_train is None or x_train is None or ids_train is None:\\n ys_train, x_train, ids_train = load_csv_data(\\\"{}/train.csv\\\".format(DATA_DIR))\\n dump_pickle_data(ys_train, \\\"ys_train\\\")\\n dump_pickle_data(x_train, \\\"x_train\\\")\\n dump_pickle_data(ids_train, \\\"ids_train\\\")\\n\\n print(\\\"PARSING TEST\\\")\\n x_test, ids_test = load_pickle_data(\\\"x_test\\\"), load_pickle_data(\\\"ids_test\\\")\\n if x_test is None or ids_test is None:\\n _, x_test, ids_test = load_csv_data(\\\"{}/test.csv\\\".format(DATA_DIR))\\n dump_pickle_data(x_test, \\\"x_test\\\")\\n dump_pickle_data(ids_test, \\\"ids_test\\\")\\n\\n return ys_train, x_train, ids_train, x_test, ids_test\",\n \"def test(self, dataset):\\n test_accuracy = 0\\n test_loss = 0\\n num_examples_tested = 0\\n # Put model into evaluation mode\\n self.model.eval()\\n for num, batch in enumerate(dataset.loader):\\n xs, ys = batch\\n batch_size = len(xs)\\n num_examples_tested += batch_size\\n iloss, iaccuracy = self.model(xs, ys)\\n test_loss += iloss.cpu().data.numpy().item() * batch_size\\n test_accuracy += iaccuracy.cpu().data.numpy().item() * batch_size\\n test_accuracy = test_accuracy / num_examples_tested\\n test_loss = test_loss / num_examples_tested\\n # Return accuracy and loss for this model on the test set\\n return test_accuracy, test_loss\",\n \"def pre_process_data(self, all_labels, all_data):\\n\\n # [1] Normalizes data\\n all_data = self.pre_precess_manager.normalization(all_data)\\n\\n data_train, data_test, label_train, label_test = train_test_split(all_data, all_labels, test_size=0.1,\\n shuffle=True)\\n\\n return data_train, data_test, label_train, label_test\",\n \"def divide_data(n_reconstructions, ratio = [.8,.1,.1], test_set = True, random = False):\\r\\n\\r\\n\\tassert np.sum(ratio) == 1.\\r\\n\\r\\n\\tif test_set:\\r\\n\\t\\tassert len(ratio) == 3\\r\\n\\r\\n\\telse:\\r\\n\\t\\tassert len(ratio) == 2\\r\\n\\t\\t\\t\\r\\n\\tif random:\\r\\n\\t\\tnp.random.seed(0)\\r\\n\\r\\n\\t\\tr = np.arange(n_reconstructions)\\r\\n\\t\\tnp.random.shuffle(r)\\r\\n\\r\\n\\t\\ti_train = r[:int(ratio[0]*n_reconstructions)]\\r\\n\\t\\ti_valid = r[int(ratio[0]*n_reconstructions):int((ratio[0]+ratio[1])*n_reconstructions)]\\r\\n\\r\\n\\t\\tif test_set:\\r\\n\\t\\t\\ti_test = r[int((ratio[0]+ratio[1])*n_reconstructions):]\\r\\n\\r\\n\\telse :\\r\\n\\t\\tr = np.arange(n_reconstructions)\\r\\n\\t\\ti_valid = r[(r+1) % int(ratio[1]*100) == 0]\\r\\n\\r\\n\\t\\tif test_set:\\r\\n\\t\\t\\ti_test = r[(r+2) % int(ratio[2]*100) == 0]\\r\\n\\t\\t\\ti_train = r[((r+1) % int(ratio[1]*100) != 0)*((r+2) % int(ratio[2]*100) != 0)]\\r\\n\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\ti_train = r[(r+1) % int(ratio[1]*100) != 0]\\r\\n\\r\\n\\tif not(test_set):\\r\\n\\t\\ti_test = []\\r\\n\\r\\n\\treturn i_train,i_valid,i_test\",\n \"def make_loader(dataset, train_batch_size, validation_split=0.2):\\n # number of samples in train and test set\\n train_len = int(len(dataset) * (1 - validation_split))\\n test_len = len(dataset) - train_len\\n train_set, test_set = torch.utils.data.random_split(dataset, [train_len, test_len])\\n # create train_loader\\n train_loader = torch.utils.data.DataLoader(\\n train_set, batch_size=train_batch_size, shuffle=True,\\n )\\n # create test_loader\\n test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False,)\\n return train_loader, test_loader\",\n \"def load_datasets(self):\\n if self.processed_extension == '.npz':\\n logger.info(f'Loading sets from npz:')\\n \\n logger.info(f'train: {self.train_path}')\\n self.train_data = sparse.load_npz(self.train_path)\\n\\n logger.info(f'val: {self.val_path}')\\n self.val_data = sparse.load_npz(self.val_path)\\n\\n logger.info(f'test: {self.test_path}')\\n self.test_data = sparse.load_npz(self.test_path)\\n \\n # Split x and y\\n self.train_data = [sparse.lil_matrix(sparse.csr_matrix(self.train_data)[:,:-1]),\\n sparse.lil_matrix(sparse.csr_matrix(self.train_data)[:,-1])]\\n \\n self.val_data = [sparse.lil_matrix(sparse.csr_matrix(self.val_data)[:,:-1]),\\n sparse.lil_matrix(sparse.csr_matrix(self.val_data)[:,-1])]\\n \\n self.test_data = [sparse.lil_matrix(sparse.csr_matrix(self.test_data)[:,:-1]),\\n sparse.lil_matrix(sparse.csr_matrix(self.test_data)[:,-1])]\\n \\n elif self.processed_extension == '.csv':\\n logger.info(f'Loading sets from csv:')\\n \\n logger.info(f'train: {self.train_path}')\\n self.train_data = pd.read_csv(self.train_path)\\n train_cols = self.train_data.columns\\n self.train_data = [self.train_data[train_cols.difference(['TARGET'])],\\n self.train_data['TARGET']]\\n \\n logger.info(f'val: {self.val_path}')\\n self.val_data = pd.read_csv(self.val_path)\\n self.val_data = [self.val_data[train_cols.difference(['TARGET'])],\\n self.val_data['TARGET']]\\n \\n logger.info(f'test: {self.test_path}')\\n self.test_data = pd.read_csv(self.test_path)\\n self.test_data = [self.test_data[train_cols.difference(['TARGET'])],\\n self.test_data['TARGET']]\\n else:\\n raise AttributeError(f'Wrong extension: {self.processed_extension}')\\n self.n_train = self.train_data[0].shape[0]\\n self.n_val = self.val_data[0].shape[0]\\n self.n_test = self.test_data[0].shape[0]\\n self.input_size = self.train_data[0].shape[1]\\n self.n_examples = self.n_train + self.n_val + self.n_test\\n \\n logger.info(f'Set sizes:')\\n logger.info(f'train: {self.n_train}')\\n logger.info(f'val: {self.n_val}')\\n logger.info(f'test: {self.n_test}')\",\n \"def create_train_test(option, transform, params, split=0.2):\\r\\n clip_im_dir = option.clip_im_dir\\r\\n matting_dir = option.matting_dir\\r\\n csv_path = option.csv_path\\r\\n \\r\\n print(\\\"create datasets\\\")\\r\\n \\r\\n \\r\\n data_df = pd.read_csv(csv_path)\\r\\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\\r\\n \\r\\n #separate data in training and test data (20/80)\\r\\n train_df, test_df = train_test_split(data_df, test_size=split)\\r\\n \\r\\n #search right Dataset class\\r\\n package_dir = Path(src.dataset.__file__).resolve().parent\\r\\n\\r\\n for (_, module_name, _) in iter_modules([package_dir]):\\r\\n # print(module_name, self.ComType)\\r\\n if option.dataset.lower() == module_name.lower() :\\r\\n modelModule = importlib.import_module(\\\".\\\"+module_name)\\r\\n break\\r\\n \\r\\n # train data\\r\\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\\r\\n train_loader = DataLoader(training_set, **params)\\r\\n \\r\\n \\r\\n #test data\\r\\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\\r\\n test_loader = DataLoader(testing_set, **params)\\r\\n \\r\\n return train_loader, test_loader\",\n \"def load_data(sample_frac):\\n # load snhunters data set\\n data = sio.loadmat('../../../../data/3pi_20x20_skew2_signPreserveNorm.mat')\\n #x = np.concatenate((data['X'], data['testX']))\\n #y = np.squeeze(np.concatenate((data['y'], data['testy'])))\\n x = data['X']\\n y = data['y']\\n # split the data into training, validation and test sets similar to MNIST\\n m = data['X'].shape[0]\\n m = m - int(.25*m)\\n split = int(sample_frac*m)\\n print(m,split)\\n x_train = data['X'][:split]\\n y_train = np.squeeze(data['y'])[:split]\\n x_valid = data['X'][split:]\\n y_valid = np.squeeze(data['y'])[split:]\\n x_test = data['testX']\\n y_test = np.squeeze(data['testy'])\\n\\n return x, y, m, split, x_train, y_train, x_valid, y_valid, x_test, y_test\",\n \"def train(self):\\n for data_tier in self.data_tiers:\\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\\n self.preprocessed_data[data_tier] = json.load(fd)\\n fd.close()\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.ceil(tot*0.8))\\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\\n t1 = datetime.datetime.utcnow()\\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\\n t2 = datetime.datetime.utcnow()\\n td = t2 - t1\\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')\",\n \"def split_data_crossvalid(data):\\n X_trainfolder = []\\n X_testfolder = []\\n y_trainfolder = []\\n y_testfolder = []\\n data = data[data[:, 0].argsort()]\\n number_one = np.count_nonzero(data[:, :1])\\n data_one = data[np.where(data[:, 0] == 1)]\\n data_zero = data[np.where(data[:, 0] == 0)]\\n one_ratio = round(number_one / len(data), 1)\\n one_zero_ratio = 1 - one_ratio\\n batch_one = int(70 * one_ratio)\\n batch_zero = int(70 * one_zero_ratio)\\n batchs = len(data) // 70\\n for i in range(batchs):\\n test_one = data_one[i * batch_one:(i + 1) * batch_one, :]\\n train_one = np.delete(data_one, test_one, axis = 0)\\n test_zero = data_zero[i * batch_zero:(i + 1) * batch_zero, :]\\n train_zero = np.delete(data_zero, test_zero, axis = 0)\\n train_sets = np.concatenate((train_one, train_zero), axis=0)\\n test_sets = np.concatenate((test_one, test_zero), axis=0)\\n np.random.shuffle(train_sets)\\n np.random.shuffle(test_sets)\\n X_trainfolder.append(train_sets[:, 1:])\\n y_trainfolder.append(train_sets[:, 0])\\n X_testfolder.append(test_sets[:, 1:])\\n y_testfolder.append(test_sets[:, 0])\\n return X_trainfolder, y_trainfolder, X_testfolder, y_testfolder\",\n \"def model(classifier, data):\\n print(\\\"Beggining to test model\\\")\\n train, test = cross_validation.train_test_split(data, test_size=.30)\\n f,c = train[:,1:], train[:,0]\\n classifier.fit(f,c,False)\\n print(\\\"Score: \\\" + classifier.score(f,c))\\n print(\\\"Finished testing model\\\")\",\n \"def load_data_from_fold(data_path):\\r\\n print(\\\"\\\\nLoading data from json folder {}\\\".format(data_path))\\r\\n\\r\\n SAMPLES_TO_CONSIDER = 22050\\r\\n\\r\\n data = preprocess_dataset(data_path, SAMPLES_TO_CONSIDER)\\r\\n\\r\\n X = np.array(data[\\\"MFCCs\\\"])\\r\\n y = np.array(data[\\\"labels\\\"])\\r\\n print(\\\"Training sets loaded!\\\")\\r\\n print(\\\"data size :\\\", X.shape, \\\"labels size: \\\", y.shape)\\r\\n print(\\\"release the 'data' for memories\\\")\\r\\n del data\\r\\n\\r\\n return X, y\",\n \"def crossValidate(dataset, folds):\\n\\tshuffle(dataset)\\n\\tcv_results = []\\n\\tprecision_recall_acc = []\\n\\tfoldSize = int(len(dataset)/folds)\\n\\tfor i in range(0,len(dataset),foldSize):\\n\\t\\t# preparing data\\n\\t\\tvalD = dataset[i:i+foldSize]\\n\\t\\ttestD = dataset[:i]+dataset[i+foldSize:] #list(set(dataset)-set(dataset[i:i+foldSize]))\\n\\t\\t# Training\\n\\t\\tprint(\\\"*\\\"*60)\\n\\t\\tprint(\\\"Training on data-set size \\\"+str(len(testD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\tclassi = trainClassifier(testD)\\n\\t\\t# Prediction on validation data \\n\\t\\tprint(\\\"Predicting on heldout data-set size...\\\"+str(len(valD))+\\\" of batch \\\"+str(i/(foldSize)))\\n\\t\\ty_true = list(map(lambda t: t[1], valD))\\n\\t\\ty_pred = predictLabels(valD,classi)\\t\\t\\n\\t\\t# Performance Metrics\\t\\t\\n\\t\\t# average based on macro as it calculate metrics for each label, and find their unweighted mean.\\n\\t\\tprecision_recall = list(precision_recall_fscore_support(y_true, y_pred, average='macro'))\\n\\t\\tacc = accuracy_score(y_true,y_pred)\\n\\t\\tprecision_recall[-1] = acc\\n\\t\\tprint(precision_recall)\\n\\t\\tprecision_recall_acc.append(precision_recall)\\n\\tdf = pd.DataFrame(precision_recall_acc,columns = [\\\"Precision\\\",\\\"Recall\\\",\\\"F1 score\\\",\\\"Accuracy Score\\\"])\\n\\tprint(df)\\n\\tcv_results = df.mean().tolist()\\n\\treturn cv_results\",\n \"def resplitData(self, cvRatio):\\n xTrain, xTest, yTrain, yTest = cross_validation.train_test_split(\\n self.x_copy, self.y_copy, test_size=cvRatio/2, random_state=None)\\n\\n yTrain = np.asmatrix(yTrain).reshape(len(yTrain),1)\\n yTest = np.asmatrix(yTest).reshape(len(yTest),1)\\n \\n # assign for later plotting\\n self.x = xTrain\\n self.y = yTrain\\n \\n return xTrain, xTest, yTrain, yTest\",\n \"def build_dataset(self):\\n print(\\\"reading data of images currently , please wait......\\\")\\n x_train, y_train, _ = get_images(self.train_directory)\\n x_test, y_test, _ = get_images(self.test_directory)\\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n self.x_train = x_train / 255\\n self.x_test = x_test / 255\\n self.y_train = utils.to_categorical(y_train, self.num_classes)\\n self.y_test = utils.to_categorical(y_test, self.num_classes)\",\n \"def init_train(self):\\n data = self.loader.load_labelled_data(self.conf.split, 'training')\\n\\n # Initialise unlabelled data iterator\\n num_ul = 0\\n if self.conf.ul_mix > 0:\\n ul_data = self.loader.load_unlabelled_data(self.conf.split, 'all')\\n\\n # calculate number of unlabelled images as a proportion of the labelled images\\n num_ul = int(data.size() * self.conf.ul_mix)\\n num_ul = num_ul if num_ul <= ul_data.size() else ul_data.size()\\n log.info('Sampling %d unlabelled images out of total %d.' % (num_ul, ul_data.size()))\\n ul_data.sample(num_ul)\\n self.gen_X_U = data_utils.generator(self.conf.batch_size, 'overflow', ul_data.images)\\n\\n # Initialise labelled data iterator\\n assert self.conf.l_mix >= 0\\n\\n # calculate number of labelled images\\n num_l = int(data.size() * self.conf.l_mix)\\n num_l = num_l if num_l <= data.size() else data.size()\\n log.info('Using %d labelled images out of total %d.' % (num_l, data.size()))\\n train_images = data.images[:num_l]\\n train_masks = data.masks[:num_l]\\n\\n self.conf.unlabelled_image_num = num_ul\\n self.conf.labelled_image_num = num_l\\n self.conf.data_len = num_ul if num_ul > num_l else num_l\\n self.conf.batches = int(np.ceil(self.conf.data_len / self.conf.batch_size))\\n self.conf.save()\\n\\n self.gen_X_L = data_utils.generator(self.conf.batch_size, 'overflow', train_images, train_masks)\\n\\n # Initialise real masks iterator for discriminator training, using the real masks from the data CV split.\\n self.other_masks = data_utils.generator(self.conf.batch_size, 'overflow', data.masks + 0)\",\n \"def partition_train_valid_test_multiview2(data, classes=None, others=None, ratio=(1,1,1), rng=np.random.RandomState(1000)):\\n if classes is None:\\n num_samples=data[0].shape[0]\\n classes=np.zeros(shape=(num_samples,),dtype=int)\\n k=sum(ratio) # ratio must be a vector of integers\\n ind=kfold_cross_validation(classes,k=k,shuffle=True,rng=rng)\\n sequence=np.arange(len(classes))\\n train_ind=np.array([],dtype=int)\\n valid_ind=np.array([],dtype=int)\\n test_ind=np.array([],dtype=int)\\n count=0\\n for ki in range(k):\\n if count<ratio[0]:\\n train_ind=np.append(train_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0] and count <ratio[0]+ratio[1]:\\n valid_ind=np.append(valid_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n if count>=ratio[0]+ratio[1] and ratio[2]>0:\\n test_ind=np.append(test_ind,sequence[ind==ki])\\n count=count+1\\n continue\\n num_views=len(data)\\n train_set_x=[None]*num_views\\n valid_set_x=[None]*num_views\\n test_set_x=[None]*num_views\\n for v in range(num_views):\\n train_set_x[v]=data[v][train_ind,:]\\n train_set_y=classes[train_ind]\\n train_set_others=others[train_ind]\\n valid_set_x[v]=data[v][valid_ind,:]\\n valid_set_y=classes[valid_ind]\\n valid_set_others=others[valid_ind]\\n test_set_x[v]=data[v][test_ind,:]\\n test_set_y=classes[test_ind]\\n test_set_others=others[test_ind]\\n return train_set_x,train_set_y,train_set_others,valid_set_x,valid_set_y,valid_set_others,test_set_x,test_set_y,test_set_others\",\n \"def read_in_and_split_data(iris_data):\\n iris_data = datasets.load_iris()\\n data = iris_data['data']\\n targets = iris_data['target']\\n train_data, test_data, train_targets, test_targets = train_test_split(data, targets, test_size=0.1) \\n return (train_data, test_data, train_targets, test_targets)\",\n \"def learnDataset(self, data_loader):\\n print(\\\"learning dataset\\\")\\n\\n count = 0\\n for sample in data_loader:\\n input_sentence = sample[\\\"input\\\"][0]\\n target_sentence = sample[\\\"target\\\"][0]\\n\\n prev_word = None\\n for word_idx in range(1, 16):\\n target_word = int(target_sentence[word_idx])\\n self.model_parts[word_idx - 1].populateFactors(\\n input_sentence, target_word, prev_word\\n )\\n prev_word = target_word\\n\\n print(\\\"{}/127940\\\".format(count), end = \\\"\\\\r\\\")\\n count += 1\\n print(\\\"127940/127940\\\")\\n\\n print(\\\"before fixed\\\", list(self.model_parts[0].factors[0].d.keys())[:10])\\n for i in range(15):\\n self.model_parts[i].fixed()\\n print(\\\"after fixed\\\", self.model_parts[0].factors[0].keys[:10])\",\n \"def load_test_dataset(self):\\n test_data_path = \\\"testdata\\\"\\n root = Path(test_data_path)\\n classes = sorted([j.name.split('/')[-1] for j in root.iterdir()])\\n print(classes)\\n\\n transform = transforms.Compose([\\n transforms.Resize(300),\\n transforms.RandomHorizontalFlip(),\\n transforms.CenterCrop(250),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.6071, 0.4828, 0.3934], std=[0.2845, 0.3187, 0.3240])\\n ])\\n\\n dataset = datasets.ImageFolder(test_data_path, transform=transform)\\n testloader = DataLoader(dataset, batch_size=4, shuffle=True)\\n print(\\\"Loaded data\\\")\\n return testloader\",\n \"def load_data_and_labels(self):\\n gen = image.ImageDataGenerator()\\n target_size = (224,224)\\n if self.preprocess:\\n print('Preprocessing data...')\\n if not os.path.isdir(self.pproc_dir()):\\n os.mkdir(self.pproc_dir())\\n \\n batch_arr = []\\n for ld,segment in [(self.train_dir(), 'train'),\\n (self.valid_dir(), 'valid')]:\\n # TODO(ness): segment = os.basename(ld)\\n flowgen = gen.flow_from_directory(\\n ld,\\n target_size=target_size,\\n shuffle=False,\\n class_mode=None,\\n batch_size=1)\\n # Save the batches using method defined in utils.py\\n data = np.concatenate([flowgen.next() for i in range(flowgen.n)])\\n batches_dir = self.pproc_dir() + segment + '-bc'\\n save_array(batches_dir, data)\\n \\n # Save the classes.\\n cls_dir = self.pproc_dir() + segment + '-cl'\\n save_array(cls_dir, flowgen.classes)\\n \\n batch_arr.append((data, flowgen.classes, flowgen.class_indices))\\n \\n # Set the data.\\n self.training_data = batch_arr[0][0]\\n self.validation_data = batch_arr[1][0]\\n \\n # Classes are zero-indexed and represent a category in\\n # numerical form. So if the classes are 'dog' and 'cat',\\n # the possible class values will be 0 and 1.\\n self.trn_classes = batch_arr[0][1]\\n self.val_classes = batch_arr[1][1]\\n \\n # Labels are the one-hot encoded (i.e. categorical)\\n # version of the classes. In other words, if there are\\n # 5 classes and an element belongs to class 2,\\n # its label will be [0,0,1,0,0] (index 1).\\n self.training_labels = to_categorical(batch_arr[0][1])\\n self.validation_labels = to_categorical(batch_arr[1][1])\\n \\n # Class indices are dictionaries of the form\\n # {'category_name': 0, 'category_name_2: 1}. They\\n # make the mapping between numerical class indices and\\n # a human-readable category name. They are (should be...)\\n # the same for validation and training, so only load them\\n # once, after sanity checking.\\n self.cindices = batch_arr[0][2]\\n print('Done preprocessing.')\\n else:\\n print('Loading data...')\\n # Load the pre-saved data using methods defined in utils.py. See\\n # preprocessing branch for the meaning of the data.\\n self.training_data = load_array(self.pproc_dir() + 'train-bc')\\n self.validation_data = load_array(self.pproc_dir() + 'valid-bc')\\n self.trn_classes = load_array(self.pproc_dir() + 'train-cl')\\n self.val_classes = load_array(self.pproc_dir() + 'valid-cl')\\n self.training_labels = to_categorical(self.trn_classes)\\n self.validation_labels = to_categorical(self.val_classes)\\n \\n # To get the class indices, we create the generator. It's cheap to\\n # run since it doesn't actually load all the data.\\n flowgen = gen.flow_from_directory(\\n self.train_dir(),\\n target_size=target_size,\\n shuffle=False,\\n class_mode=None,\\n batch_size=1) \\n self.cindices = flowgen.class_indices\\n print('Done loading.')\",\n \"def DataSplit(self, data):\\n train_X,test_X,train_y,test_y=train_test_split(data[0],data[1], random_state=2)\\n valid_X,valid_y=train_test_split(data[0],data[1],random_state=2,test_size=0.15)[1],train_test_split(data[0],data[1],random_state=2,test_size=0.15)[3]\\n return (train_X,test_X,valid_X,train_y,test_y,valid_y)\",\n \"def train(self, data_loader):\\n step = 0\\n train_data, valid_data = data_loader()\\n\\n # Allow to call `next` builtin indefinitely.\\n valid_data = iter(valid_data.repeat())\\n\\n for epoch in range(self.hparams.num_epochs):\\n for x, y in train_data:\\n\\n with tf.GradientTape() as g:\\n train_loss = self.loss(y, self(x))\\n\\n grads = g.gradient(train_loss, self.trainable_variables)\\n self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\\n\\n # Validate every 1000 training steps.\\n if step % 1000 == 0:\\n x, y = next(valid_data)\\n valid_loss = self.loss(y, self(x))\\n print(\\n f\\\"step {step} (train_loss={train_loss} valid_loss={valid_loss})\\\"\\n )\\n step += 1\\n\\n print(f\\\"epoch {epoch} finished\\\")\\n self.save()\",\n \"def get_train_val_test_datasets(\\n rnd: np.random.RandomState,\\n root='~/data',\\n validation_ratio=0.05,\\n) -> tuple:\\n\\n transform = transforms.Compose(\\n [\\n transforms.ToTensor()\\n ]\\n )\\n\\n train_set = CIFAR100(\\n root=root,\\n train=True,\\n download=True,\\n transform=transform\\n )\\n\\n # create validation split\\n if validation_ratio > 0.:\\n train_set, val_set = _train_val_split(rnd=rnd, train_dataset=train_set, validation_ratio=validation_ratio)\\n\\n # create a transform to do pre-processing\\n train_loader = DataLoader(\\n train_set,\\n batch_size=len(train_set),\\n shuffle=False,\\n )\\n\\n data = iter(train_loader).next()\\n dim = [0, 2, 3]\\n mean = data[0].mean(dim=dim).numpy()\\n std = data[0].std(dim=dim).numpy()\\n # end of creating a transform to do pre-processing\\n\\n transform = transforms.Compose(\\n [\\n transforms.ToTensor(),\\n transforms.Normalize(\\n mean, std\\n ),\\n ])\\n\\n train_set.transform = transform\\n\\n if validation_ratio > 0.:\\n val_set.transform = transform\\n else:\\n val_set = None\\n\\n test_set = CIFAR100(\\n root=root,\\n train=False,\\n download=True,\\n transform=transform\\n )\\n\\n return train_set, val_set, test_set\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7038124","0.68708676","0.6773931","0.66979957","0.6655997","0.66537637","0.6629245","0.6622395","0.6614368","0.6608594","0.6596205","0.65692824","0.6518721","0.6510277","0.6498947","0.6481965","0.64735436","0.64697593","0.64670414","0.64647627","0.64571387","0.6439737","0.6434837","0.6428973","0.6413247","0.6409055","0.64031994","0.63979584","0.6396936","0.6392475","0.6390692","0.6379355","0.63594633","0.6351955","0.63504326","0.6343941","0.634131","0.63306695","0.6317433","0.6311704","0.62974256","0.62966806","0.62918705","0.6271488","0.6259376","0.62522733","0.62406725","0.6238459","0.62375236","0.62375236","0.623513","0.6234443","0.62312233","0.6226213","0.62240905","0.6220305","0.6220155","0.62194186","0.6216888","0.6212787","0.6206159","0.6202984","0.6201455","0.61973494","0.6192746","0.61787105","0.6176458","0.6167517","0.6167491","0.6160162","0.61526906","0.6147388","0.6146656","0.61429214","0.6136949","0.613576","0.6133619","0.61288047","0.6127148","0.6124654","0.6124642","0.61244327","0.6123796","0.61190987","0.61184055","0.6116285","0.6115058","0.61148983","0.6110628","0.61050224","0.61043155","0.6103375","0.6100071","0.6096906","0.60940516","0.6092207","0.6089753","0.60851884","0.6083885","0.60817546"],"string":"[\n \"0.7038124\",\n \"0.68708676\",\n \"0.6773931\",\n \"0.66979957\",\n \"0.6655997\",\n \"0.66537637\",\n \"0.6629245\",\n \"0.6622395\",\n \"0.6614368\",\n \"0.6608594\",\n \"0.6596205\",\n \"0.65692824\",\n \"0.6518721\",\n \"0.6510277\",\n \"0.6498947\",\n \"0.6481965\",\n \"0.64735436\",\n \"0.64697593\",\n \"0.64670414\",\n \"0.64647627\",\n \"0.64571387\",\n \"0.6439737\",\n \"0.6434837\",\n \"0.6428973\",\n \"0.6413247\",\n \"0.6409055\",\n \"0.64031994\",\n \"0.63979584\",\n \"0.6396936\",\n \"0.6392475\",\n \"0.6390692\",\n \"0.6379355\",\n \"0.63594633\",\n \"0.6351955\",\n \"0.63504326\",\n \"0.6343941\",\n \"0.634131\",\n \"0.63306695\",\n \"0.6317433\",\n \"0.6311704\",\n \"0.62974256\",\n \"0.62966806\",\n \"0.62918705\",\n \"0.6271488\",\n \"0.6259376\",\n \"0.62522733\",\n \"0.62406725\",\n \"0.6238459\",\n \"0.62375236\",\n \"0.62375236\",\n \"0.623513\",\n \"0.6234443\",\n \"0.62312233\",\n \"0.6226213\",\n \"0.62240905\",\n \"0.6220305\",\n \"0.6220155\",\n \"0.62194186\",\n \"0.6216888\",\n \"0.6212787\",\n \"0.6206159\",\n \"0.6202984\",\n \"0.6201455\",\n \"0.61973494\",\n \"0.6192746\",\n \"0.61787105\",\n \"0.6176458\",\n \"0.6167517\",\n \"0.6167491\",\n \"0.6160162\",\n \"0.61526906\",\n \"0.6147388\",\n \"0.6146656\",\n \"0.61429214\",\n \"0.6136949\",\n \"0.613576\",\n \"0.6133619\",\n \"0.61288047\",\n \"0.6127148\",\n \"0.6124654\",\n \"0.6124642\",\n \"0.61244327\",\n \"0.6123796\",\n \"0.61190987\",\n \"0.61184055\",\n \"0.6116285\",\n \"0.6115058\",\n \"0.61148983\",\n \"0.6110628\",\n \"0.61050224\",\n \"0.61043155\",\n \"0.6103375\",\n \"0.6100071\",\n \"0.6096906\",\n \"0.60940516\",\n \"0.6092207\",\n \"0.6089753\",\n \"0.60851884\",\n \"0.6083885\",\n \"0.60817546\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67273855"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9456,"cells":{"query":{"kind":"string","value":"gR(D,A) = (H(D) H(D|A)) / H(D|A)"},"document":{"kind":"string","value":"def _cal_igr(x, y):\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)"},"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 g(self, RD):\n g = 1 / np.sqrt((1 + 3 * np.power(self.q, 2)) / np.power(np.pi, 2)) \n \n return g","def g(r):\n return np.cos(r) / (np.exp(0.4 * (r - 8)) + 1)","def r0(self):\n return self.p[0] / self.p[1]","def get_rm(g):\n return 1 / g","def calculate_gear_ratio(front_gear, back_gear):\n return front_gear/back_gear","def DG(self, n, e, r, f):\n\n pre = -e[:, None] + np.divide.outer((n - 1), r)\n return pre*f","def compute_Rg(L):\n\treturn np.sqrt(np.dot(L,L))","def acc_grav(j,rA,mA,hA,W=kernel.W_M4star):\n assert rA.shape[0] == mA.shape[0] == hA.shape[0], \"arrays are mismatched\"\n N = len(mA)\n\n tot = 0\n for i in range(N):\n if i != j:\n\n r_ij = rA[j,:] - rA[i,:]\n r_ij1 = np.linalg.norm(r_ij)\n m_i = mA[i]\n h_ij = 0.5 * (hA[i] + hA[j])\n\n tot += m_i * (r_ij/r_ij**3) * W(r_ij1,h_ij)\n\n return - tot * G","def g_d(self, z):\n a = self.g(z)\n return a * (1 - a)","def get_R(R_e,R_h):\n R = R_e + R_h\n return R","def g(self, r, mu):\n\n return np.sqrt(1. - (r / self.R)**2 * (1. - mu**2))","def guza2012(H,L,Fw,Ds=1.0):\n \n # Make sure parameters are double precision\n H = np.double(H)\n L = np.double(L)\n Fw = np.double(Fw)\n Ds = np.double(Ds)\n \n Fp = (2.0 * np.pi * L / 9.81)**-0.5\n \n # Compute R2% IG (Equation 4) \n r2 = (-0.013 * np.log(Fp/Fw*Ds) + 0.058) * ((H * L)**0.5)\n \n return r2","def calc_D(state):\n\t\tif t < thresh:\n\t\t\tstate.D_g[t] = 0.5\n\t\t\tstate.D_n[t] = 0.5\n\t\telse:\n\t\t\tif mod == \"constant\":\n\t\t\t\tstate.D_g[t] = D\n\t\t\t\tstate.D_n[t] = 1-D\n\t\t\tif mod == \"value\":\n\t\t\t\t# NOTE: if rmag and lmag is 1/0, can just use V\n\t\t\t\t# average of two actions\n\t\t\t\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \n\t\t\t\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\n\t\t\t\tstate.D_g[t] = V \n\t\t\t\tstate.D_n[t] = 1 - V\n\t\treturn state","def DR(R,Pc):\n return r1*R*(K1**B1/(K1**B1 + (A/R)**B1))*(S/(S + R*Pc + Pc)) \\\n - gwt*A - r2*R*(K2**B2/(K2**B2 + (A)**B2))*(S/(S + R*Pc + Pc) ) \\\n *(R*M)/(K3 + R*M) + R*gc","def G(U):\n n = U.shape[0]\n G_U = np.zeros([n,1])\n DELTA_x = float(2*L)/(n-1)\n for i in range(n):\n G_U[i][0] = U[(i+1)%n][0]\n G_U[i][0] -= U[(i-1)%n][0]\n G_U[i][0] /= (2* DELTA_x)\n G_U[i][0] += (float(epsilon) * (U[(i+1)%n][0]- U[(i-1)%n][0]) * (U[(i-1)%n][0]+U[(i+1)%n][0]+ U[i][0])/ (4* DELTA_x))\n G_U[i][0] += (float(epsilon) * (U[(i+2)%n][0]- 2*U[(i+1)%n][0]+ 2*U[(i-1)%n][0]- U[(i-2)%n][0]) / (12*( DELTA_x**3)))\n return G_U","def g(self, p):\n re = self._re(p)\n Le = self._Le(p)\n wf = self._wf(p)\n rf = self._rf(p)\n A = Le @ np.einsum('...ij,...j', self.Ee, re)\n B = wf @ np.einsum('...ij,...j', self.Ff, rf)\n return (B - A) * G * self.d","def dfr(self):\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])","def reciprocity_ratio(gd):\r\n reciprocal = 0.0\r\n edge_list = gd.get_edgelist()\r\n for i in it.permutations(range(gd.vcount()),2):\r\n if i in edge_list and i[::-1] in edge_list:\r\n reciprocal += 1.0\r\n return reciprocal/gd.ecount()","def r_d(self, tl):\n\t return self.RD0*exp(self.HKR/(R*self.TO)*(1. - self.TO/tl))","def total_potential_energy(R,M,G):\r\n U = 0\r\n N = R.shape[0] \r\n \r\n for n in range(N):\r\n for nn in range(n+1,N):\r\n U = U - G*M[n]*M[nn] / util.enod(R[n,:],R[nn,:])\r\n \r\n return U","def _grads(val, r):\n return grad(val, r, grad_outputs=torch.ones_like(val))[0]","def qr_mgs( A ):\n\n A = numpy.array(A, dtype=float)\n m,n = A.shape\n Q = numpy.zeros( (m,n) )\n R = numpy.zeros( (n,n) )\n\n for k in range( 0, n ) :\n R[k,k] = numpy.linalg.norm( A[:,k] )\n Q[:,k] = A[:,k] / R[k,k]\n\n for j in range( k+1, n ) :\n R[k,j] = numpy.dot( Q[:,k], A[:,j] )\n A[:,j] = A[:,j] - Q[:,k] * R[k,j]\n \n return Q,R","def V(E, g, gl):\n num = 0\n den = 0\n for i in range(len(E)):\n num += E[i][0]*g[i][0] + E[i][1]*g[i][1]\n den += g[i][0] + g[i][1] + gl\n return num / den","def residualsG(p, data):\n \n x, y, err = data\n return (y-funcG(p,x)) / err","def calc_a(dert__):\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g","def R(w,h):\n\ta = h/3.0\n\tbeta = atan2(a,w)\n\tc = sqrt(a**2 + w**2)\n\td = c/2.0\n\te = d/sin(beta)\n\treturn e-a","def get_R_h(E, M, l, g_h, T_h):\n # transform energy-vector into matrices\n mat_E_x, mat_E_y = np.meshgrid(E,E) \n mat_diff = mat_E_y - mat_E_x # matrix representing: E_i - E_j\n \n # leave out the sine-terms at first\n R_h = np.ones((M,M))*g_h**2 * T_h*4 # matrix for transition rates\n ind = np.abs(mat_diff) > 0 # indices of the non-divergent elements\n # fill in just those elements without divergences 1/0\n # the rest is set to the correct limit\n R_h[ind] = g_h**2 *4* mat_diff[ind]/(np.exp(mat_diff[ind]/T_h)-1)\n \n # multiply the sine-terms\n sin = np.sin(l*np.arange(1,M+1)*np.pi/(M+1))**2 # vector with sine-values sin(li)**2\n # transform sine-vectors into matrices\n mat_sin_x, mat_sin_y = np.meshgrid(sin,sin)\n R_h *= mat_sin_x * mat_sin_y\n \n return R_h","def ga_log(R):\n phiP, t_normal_n, t_perpendicular_n = extractRotorComponents(R)\n return phiP + t_normal_n + t_perpendicular_n","def h(x, w, r):\n r = r.unsqueeze(-1)\n \n return (r ** 2 - torch.norm(w, dim = -1, keepdim=True) ** 2) / (torch.norm(x - w, dim = -1, keepdim = True) ** 2) * (x - w) - w","def density_by_ideal_gas_law(\n p: tf.Tensor,\n r: tf.Tensor,\n t: tf.Tensor,\n ) -> tf.Tensor:\n return p / r / t","def g_1(self, R, elements):\n values = numpy.exp(-self.eta * (R - self.r_s) ** 2) * self.f_c(R)\n numpy.fill_diagonal(values, 0)\n\n elements = numpy.array(elements)\n\n totals = []\n for ele in self._elements:\n idxs = numpy.where(elements == ele)[0]\n total = values[:, idxs].sum(1)\n totals.append(total)\n return numpy.array(totals).T","def reciprocal(self):\n return Rational(self.denominator, self.numerator)","def H_G(X):\n n = X.shape[0]\n H = np.zeros([n,n])\n DELTA_x = float(2*L)/(n-1)\n for i in range(n):\n H[i][(i-2)%n] = - float(epsilon) / (12 * (DELTA_x**3))\n H[i][(i-1)%n] = (-2. - float(epsilon) * (X[i][0] + 2*X[(i-1)%n][0])) / (4 * DELTA_x) + 2. * (float(epsilon)/(12*(DELTA_x**3)))\n H[i][i] = (epsilon * (X[(i+1)%n][0] - X[(i-1)%n][0])) / (4 *DELTA_x)\n H[i][(i+1)%n] = (2. + float(epsilon) * (X[i][0] + 2*X[(i+1)%n][0])) / (4 * DELTA_x) - 2. * (float(epsilon)/(12*(DELTA_x**3)))\n H[i][(i+2)%n] = float(epsilon) / (12 * (DELTA_x)**3) \n return H","def sag_ratio(V):\n\n Vmin = np.amin(V)\n Vend = V[-1]\n sr = (Vmin - Vend) / Vmin\n if sr < 0:\n print(\"Warning: sag ratio being negative indicates there is no sag\")\n return sr","def js_div(d1, d2):\n part1 = - soft_relu(-d1).mean()\n part2 = - soft_relu(d2).mean() \n return part1 + part2 + np.log(4.0)","def R(self):\n\t\treturn (arange(self.rbins) + 0.5) * (self.cbins - 0.5) / self.rbins","def compute_gae(V, s, ss, r, absorbing, last, gamma, lam):\n v = V(s)\n v_next = V(ss)\n gen_adv = np.empty_like(v)\n for rev_k in range(len(v)):\n k = len(v) - rev_k - 1\n if last[k] or rev_k == 0:\n gen_adv[k] = r[k] - v[k]\n if not absorbing[k]:\n gen_adv[k] += gamma * v_next[k]\n else:\n gen_adv[k] = r[k] + gamma * v_next[k] - v[k] + gamma * lam * gen_adv[k + 1]\n return gen_adv + v, gen_adv","def calc_f_g(mu, x, t, ro, inv_a):\n z = inv_a*pow(x,2)\n f = 1 - pow(x,2)/ro*stump_C(z) \n g = t - 1/sqrt(mu)*pow(x,3)*stump_S(z)\n return f, g","def div(f, g):\n lev, dom, per, F, G = f.unify(g)\n q, r = dmp_div(F, G, lev, dom)\n return per(q), per(r)","def hr_egn(A, B, R, x0):\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Degree and degree of preferences\n d = np.zeros([N, 2])\n d[:, 0] = np.dot(A, np.ones(N))\n\n for v in range(N):\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\n\n # Player v neighborhood\n k = np.zeros([N, S], dtype='double')\n for v in range(N):\n for u in range(N):\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\n # Weights the neighborhood\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\n\n # This variable is the increments that x0 receives, the derivative\n x = np.zeros([N, S], dtype='double')\n # This is the unit vector with 1 in some entry\n es = np.zeros(S, dtype='int')\n\n # Phi and gamma\n p = 0\n g = 0\n\n # Auxiliary variables for better clarity\n aux1 = 0\n aux2 = 0\n\n # Here is the derivative calculation\n # We first test if all payoffs are the same so we do less comparisons\n if B.ndim == 2:\n for v in range(N):\n for s in range(S):\n # Set es value\n es[s] = 1\n for u in range(N):\n if v == u:\n # Same payoff personal equation\n # First we will do the dot products\n # e_s*B*k_v\n aux1 = np.dot(es, np.dot(B, k[v, :]))\n # x_v*B*k_v\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\n # Finally we subtract them to multiply by r_vv\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Same payoff social equation\n # x_u*B*e_s\n aux1 = np.dot(x0[u, :], np.dot(B, es))\n # x_u*B*x_v\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n else:\n for v in range(N):\n for s in range(S):\n # Same thing as before, but now with individual payoffs\n es[s] = 1\n for u in range(N):\n if v == u:\n # Individual payoffs personal equation\n # e_s*B_v*k_v\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\n # x_u*B_v*k_v\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Individual payoffs social equation\n # x_u*B_u*e_s\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\n # x_u*B_u*x_v\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n return x","def Rfun(U,V,Q,Phi,Phibar, taudrag):\n \n Qclone=Q.copy()\n Qclone[Q<0]=0\n\n Ru=np.divide(np.multiply(-U,Qclone),Phi+Phibar)\n Rv=np.divide(np.multiply(-V,Qclone),Phi+Phibar)\n \n #reset to 0 if losing mass\n Ru[Q<0]=0\n Rv[Q<0]=0\n \n #if taudrag is infinity, only have the R componen \n if taudrag!=-1:\n F=Ru-(U/taudrag)\n G=Rv-(V/taudrag)\n \n else:\n F=Ru\n G=Rv\n \n return F, G","def gru(params, h, x):\n bfg = 0.5\n hx = np.concatenate([h, x], axis=0)\n ru = sigmoid(np.dot(params['wRUHX'], hx) + params['bRU'])\n r, u = np.split(ru, 2, axis=0)\n rhx = np.concatenate([r * h, x])\n c = np.tanh(np.dot(params['wCHX'], rhx) + params['bC'] + bfg)\n return u * h + (1.0 - u) * c","def wer(r, h):\n #build the matrix\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8).reshape((len(r)+1, len(h)+1))\n for i in range(len(r)+1):\n for j in range(len(h)+1):\n if i == 0: d[0][j] = j\n elif j == 0: d[i][0] = i\n for i in range(1, len(r)+1):\n for j in range(1, len(h)+1):\n if r[i-1] == h[j-1]:\n d[i][j] = d[i-1][j-1]\n else:\n substitute = d[i-1][j-1] + 1\n insert = d[i][j-1] + 1\n delete = d[i-1][j] + 1\n d[i][j] = min(substitute, insert, delete)\n result = float(d[len(r)][len(h)]) / len(r) * 100\n result = str(\"%.2f\" % result) + \"%\"\n return d[len(r)][len(h)]\n #find out the manipulation steps","def gradh(self,q):\n gx = self.d_i(q) / self.e1u\n gy = self.d_j(q) / self.e2v\n #\n return gx,gy","def reward_function(self):\r\n def R(state, decision, nodes):\r\n return -1.0/1000*nodes['G'].get_preds_value(state)*(decision['G:R_1']+decision['G:L'])\r\n \r\n return R","def d1(self):\r\n numerator = math.log(self.s/self.x) + (self.rf-self.div+self.sigma**2*0.5)*self.t # Numerator of d1\r\n denominator = self.sigma * self.t**0.5 # Denominator of d1\r\n \r\n return numerator/denominator","def M_g(self):\n\n print(\"\", file=self.logfile)\n print(\"Updating g\", file=self.logfile)\n M_mu1 = np.lib.stride_tricks.as_strided(self.mu_pad,\n shape=[self.P+1, self.L_h],\n strides=[self.mu_pad.strides[-1], self.mu_pad.strides[-1]])\n\n M_mu1 = M_mu1[::-1,:]\n M_mu2 = np.transpose(M_mu1[1:,:])\n M_mu1 = M_mu1*self.e2\n\n M_mu = np.dot(M_mu1, M_mu2)\n v_mu = M_mu[0,:]\n M_mu = M_mu[1:,:]\n\n M_R = np.zeros((self.P,self.P+1))\n for p in range(1,self.P+1):\n for q in range(0,self.P+1):\n M_R[p-1,q] = np.sum(np.diag(self.R, q-p)[:self.L_h-max(p,q)]*self.e2[max(p,q):self.L_h])\n\n v_R = M_R[:,0]\n M_R = M_R[:,1:]\n\n self.alpha_g = np.dot(np.linalg.inv(M_mu + M_R), v_mu+v_R)\n self.A = np.concatenate([[1], -self.alpha_g])\n\n self._propagate_A()","def mamajek08_logRpHK_Ro_edge():\n Ro_edge = 0.31935816876122064\n return Ro_edge","def _gs_step(r: jax.ShapedArray,\n v_i: jax.ShapedArray) -> Tuple[jax.ShapedArray, jax.ShapedArray]:\n h_i = jnp.vdot(v_i, r)\n r_i = r - h_i * v_i\n return r_i, h_i","def solve_R(R, b):\n n = b.size\n assert R.shape == (n,n)\n x = zeros(n, dtype=R.dtype)\n for i in range(n-1,-1,-1):\n x[i] = (b[i] - dot(x[i+1:], R[i,i+1:])) / R[i,i]\n if not numpy.isfinite(x[i]):\n x[i] = 0.0\n return x","def _gcl(x, r, D, Ia, Ct):\n\n Area = np.pi * D ** 2.0 / 4.0\n m = 1.0 / (np.sqrt(1.0 - Ct))\n k = np.sqrt((m + 1.0) / 2.0)\n\n a1 = 0.435449861 # empirically determined\n a2 = 0.797853685\n a3 = -0.124807893\n a4 = 0.136821858\n b1 = 15.6298\n b2 = 1.0\n R96 = a1 * (np.exp(a2 * Ct * Ct + a3 * Ct + a4)) * (b1 * Ia + b2) * D\n\n x0 = (9.6 * D) / ((2.0 * R96 / (k * D)) ** 3.0 - 1.0)\n term1 = (k * D / 2.0) ** (5.0 / 2.0)\n term2 = (105.0 / (2.0 * np.pi)) ** (-0.5)\n term3 = (Ct * Area * x0) ** (-5.0 / 6.0)\n c1 = term1 * term2 * term3\n # c45=3*(c1) ** 2\n\n term10 = 0.1111 # * WindSpeed # U/9.0\n term20 = (Ct * Area * (x + x0) ** (-2.0)) ** (1.0 / 3.0)\n term310 = (r ** (3.0 / 2.0))\n term320 = (3.0 * c1 * c1 * Ct * Area * (x + x0)) ** (-0.5)\n term30 = term310 * term320\n term40 = ((35.0 / (2.0 * np.pi)) ** (3.0 / 10.0)) * \\\n (3.0 * c1 * c1) ** (-1.0 / 5.0)\n DU1 = -term10 * term20 * (term30 - term40) ** 2.0\n\n DU = DU1 # + w2 * DU2\n Rw = ((105 * c1 ** 2.0 / (2 * np.pi)) ** (1. / 5.)) * \\\n (Ct * Area * (x + x0)) ** (1. / 3.)\n return DU, Rw","def numerator(self,data,gold):\n gold_size = 0.0\n for lead in gold.keys():\n gold_size += len(gold[lead])\n print gold_size\n epsilon = 0.0000000001\n match = 0.0\n not_match = 0.0\n exp_size = 0.0\n for lead in data.keys():\n for hit in data[lead]:\n exp_size += 1\n edge = (lead,hit[0])\n if self.CompareEdges(edge,gold):\n print edge\n match += 1\n else:\n not_match += 1\n\n if match == 0.0:\n match = epsilon\n elif not_match == 0.0:\n not_match = epsilon\n print match\n print not_match\n num1 = match \n num2 = not_match\n return num1/num2","def calc_a(r):\n r3 = np.hypot(*r)**3\n return -fac * r / r3","def gamma(a,b,c,d):\n g1 = max((c + d) * (1 - b) * b / (c*d * np.math.log(2)), 0.0)\n g2 = max((c + d) * 21**2 / (c*d * (1 - b) * b*a**2), 1.0)\n g = np.math.sqrt(g1 * np.math.log(g2, 2))\n return g","def dcg(self, ranking_relevances):\n return sum([(2 ** relevance - 1) / math.log(rank + 2, 2) for rank, relevance in enumerate(ranking_relevances)])","def pollard_rho(g: int, h: int, n: int, order: int = None):\n x = {0: 1}\n a = {0: 0}\n b = {0: 0}\n\n import ressources.multGroup as multGroup\n\n if order is None:\n order = multGroup.multiplicativeOrder(g, n)\n\n # from a, b and c, partitioning the field\n def step_xab(x, a, b, g, h, order, n):\n s = x % 3\n\n # S1\n if s == 1:\n x = x * h % n\n b = (b + 1) % order\n\n # S2\n if s == 0:\n x = square_and_multiply(x, 2, n)\n a = 2 * a % order\n b = 2 * b % order\n\n # S3\n if s == 2:\n x = x * g % n\n a = (a + 1) % order\n\n return x, a, b\n\n # returns x, a, b for a given i using memoization\n def get_xab(i):\n\n if i not in x:\n _x, _a, _b = get_xab(i - 1)\n\n x[i], a[i], b[i] = step_xab(_x, _a, _b, g, h, order, n)\n\n return x[i], a[i], b[i]\n\n def naturals_from(i):\n while True:\n # yield is a keyword that is used like return, except the function will return a generator.\n # https://www.google.com/search?client=firefox-b-d&q=yield+python\n yield i\n i += 1\n\n for i in naturals_from(1):\n\n x_i, a_i, b_i = get_xab(i)\n x_2i, a_2i, b_2i = get_xab(2 * i)\n\n if x_i == x_2i:\n\n r = (b_i - b_2i) % order\n\n if r == 0:\n return False\n\n return multGroup.inv(r, order) * (a_2i - a_i) % order","def getR(self):\n # Reynolds number uses the absolute value of the velocity\n V = abs(self.V)\n return (V * self.D) / self.v # formula for Reynolds number","def __rdiv__(self, other):\n return self.__rtruediv__(other)","def Re(self, rho, u, d_p, mu):\n return rho*u*d_p/mu","def G_core(self, r, b=-1):\n return self.from_G_charges_and_quotient(self.G_charges(r,b), quotient=None, r=r, b=b)","def g(x):\n return 5. - x[:, 1] - .5 * x[:, 0] ** 2.","def calc_V(A):\n return 1. / calc_rV(A)","def dense_gammaln_ratio(x, weights, deriv=0):\n if deriv == 0:\n func = gammaln\n elif deriv == 1:\n func = digamma\n else:\n raise NotImplementedError('Only derivatives up to first order supported')\n counts = np.where(weights)[0]\n weights = weights[counts]\n return func(x[:, None] + counts[None, :]).dot(weights) - func(x) * weights.sum()","def acceleration(R,M,G):\r\n N = R.shape[0]\r\n a = np.zeros((N,3)) # initialize accelerations\r\n for n in range(N):\r\n for nn in range(N):\r\n if n!=nn:\r\n a[n,:] += G*M[nn] * (R[nn,:]-R[n,:]) / util.enod(R[nn,:],R[n,:])**(3) \r\n return a","def pdiv(f, g):\n lev, dom, per, F, G = f.unify(g)\n q, r = dmp_pdiv(F, G, lev, dom)\n return per(q), per(r)","def DDG(self, n, e, r, f):\n pre = (-e[:, None] + np.divide.outer((n - 1), r))**2\n pre -= np.divide.outer((n - 1), r**2)\n return pre*f","def\tfOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw):\n\tSum=Vc1+Vc2+Vc3+Vk+Vrw\n\tOrmGDen=(Vc1*Dc1+Vc2*Dc2+Vc3*Dc3+Vk*Dk+Vrw*Dw)/Sum\n\treturn OrmGDen","def g(self, X):\n\n return (X[0])**2 - 2*X[0] + X[1]**3 - 2","def dcg(self, ranking):\n return sum([(2**r-1)/math.log(i+2,2) for i,r in enumerate(ranking)])","def _h(W):\r\n # E = slin.expm(W * W)\r\n # h = np.trace(E) - d\r\n M = np.eye(d) + W * W / d\r\n E = np.linalg.matrix_power(M, d - 1)\r\n h = (E.T * M).sum() - d\r\n G_h = E.T * W * 2\r\n return h, G_h","def calc_rV(A):\n return np.sqrt(calc_rVsq(A))","def photon_fraction(r, r1, r2):\n return rotate_phasor(r, r1, r2).real","def dcg(relevances, rank=10):\n relevances = np.asarray(relevances)[:rank]\n n_relevances = len(relevances)\n if n_relevances == 0:\n return 0.\n\n discounts = np.log2(np.arange(n_relevances) + 2)\n return np.sum(relevances / discounts)","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def r_pgh(self, sigma, delta_c, f_nl):\n\n if (f_nl < 0):\n \n f_nl = abs(f_nl)\n\n delta_c = sqrt(0.837)*delta_c #Tinker / sph. collapse correction factor.\n\n nu = delta_c / sigma\n pgh_ng=0.e0\n e_1 = 3.e-4 * f_nl\n\n pgh_ng = sqrt(1.e0/( 1 + e_1*nu )) * exp( (nu*nu/2.e0) + (1/(e_1*e_1))*( e_1*nu - (1+e_1*nu)*log(1+e_1*nu) ) )\n\n return 1.e0/pgh_ng\n\n elif (f_nl == 0):\n return 1.e0\n else:\n \n delta_c = sqrt(0.837)*delta_c #Tinker / sph. collapse correction factor.\n\n nu = delta_c / sigma\n pgh_ng=0.e0\n e_1 = 3.e-4 * f_nl\n\n pgh_ng = sqrt(1.e0/( 1 + e_1*nu )) * exp( (nu*nu/2.e0) + (1/(e_1*e_1))*( e_1*nu - (1+e_1*nu)*log(1+e_1*nu) ) )\n\n return pgh_ng","def do_dr(r, t):\n return 1/t**0.5","def H(x, X, Y, dY):\n\n def L(i):\n #return p[i] * (x ** i)\n p = [(x - X[i]) / (X[j] - X[i]) for j in range(n) if j != i]\n return reduce(op.mul, p)\n\n def dL(i):\n #return d[i-1] * (x ** (i-1))\n if i < n-1:\n return (Y[i+1] - Y[i]) / (X[i+1] - X[i])\n else:\n return (Y[i] - Y[i-1]) / (X[i] - X[i-1])\n\n def A(i):\n return (1 - 2 * (x - X[i]) * dL(i)) * (L(i) ** 2)\n\n def B(i):\n return (x - X[i]) * (L(i) ** 2)\n\n assert(len(X) != 0 and len(X) == len(Y)), 'Quantidade de valores em X e Y diferentes'\n n = len(X)\n #p = interpolate.lagrange(X, Y)\n #d = polyder(p)\n h1 = sum(A(i) * Y[i] for i in range(n))\n h2 = sum(B(i) * dY[i] for i in range(n))\n return h1 + h2","def expected_g(self):\n raise NotImplementedError()\n # \\sum_{b} \\gamma_b\n trm2 = self.mf_gamma.sum(axis=2)\n E_g = self.mf_gamma / trm2[:,:,None]\n return E_g","def get_rel_residuals(dfr, var):\n gen_var = 'gen_' + var\n return (dfr.loc[:, var] - dfr.loc[:, gen_var]) / dfr.loc[:, gen_var]","def mapd(self) -> float:\n a = np.sum(np.abs(self.predicted - self.true))\n b = np.sum(np.abs(self.true))\n return float(a / b)","def fun_lorentzian_p_gauss(p,r):\n return p[1] / ((r/p[0])**2 + 1) + p[2] * np.exp(-((r/p[0])**2)/2)","def xgcd(self, a):\n s, old_s = [0], [1]\n t, old_t = [1], [0]\n r, old_r = self.coef, a\n\n while sum(r) != 0:\n quotient = self.poly_round_div(old_r, r)\n old_r, r = r, [sum(x) % self.mod for x in\n itertools.zip_longest(old_r, [x * (-1) for x in self._mul_coef(quotient, r)], fillvalue=0)]\n old_s, s = s, [sum(x) % self.mod for x in\n itertools.zip_longest(old_s, [x * (-1) for x in self._mul_coef(quotient, s)], fillvalue=0)]\n old_t, t = t, [sum(x) % self.mod for x in\n itertools.zip_longest(old_t, [x * (-1) for x in self._mul_coef(quotient, t)], fillvalue=0)]\n while len(r) and r[-1] == 0:\n r.pop()\n return old_r, old_s, old_t\n # # old_r[0]이 1이 아닌경우는 old_r[0]으로 나눠야 한다.\n # old_s_inv = mul_inverse_mod(old_r[0], self.mod)\n # # result = [ x % 3 for x in self.poly_mul2(old_s, [old_s_inv])]\n # result = [x % self.mod for x in self._mul_coef(old_s, [old_s_inv])]\n # return result + ([0] * (len(self.irr_coef) - len(result)))","def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\n ratio_x = 0\n ratio_y = 0\n ratio_z = 0\n # helm_B = [0,0,0]\n divideby = 0\n for shot in range(shot_range[0], shot_range[1]+1):\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\n ratio_x = ratio_x + x\n ratio_y = ratio_y + y\n ratio_z = ratio_z + z\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\n divideby = divideby + 1 #averaging over the number of shots\n ratio_Bx = ratio_x/divideby\n ratio_By = ratio_y/divideby\n ratio_Bz = ratio_z/divideby\n # helmB = [helm_B]/divideby\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\n # print(\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\n Bx_sqr =ratio_x**2\n By_sqr =ratio_y**2\n Bz_sqr =ratio_z**2\n B = Bx_sqr + By_sqr+ Bz_sqr\n norm_factor = np.sqrt(B)\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\n\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)","def _get_A_rdm(self, p):\n\n return rdm_graph(self.G, nodelist=self.nodelist, percent=p)","def rh(self, h):\n sez=self.getSect(h)\n area=self.area(sez)\n wetborder = self.wetBorder(sez)\n return area/wetborder","def cache_gH(self):\n self.gH.fill(0.)\n for lag, Wl in enumerate(self.W):\n self.gH += s_dot(Wl.T, self.resids, -lag)\n return self.gH","def retarded_gf(h_ao, s_ao, energy, gamma_left, gamma_right):\n return np.linalg.inv(energy*s_ao - h_ao + (1j/2.)*(gamma_left + gamma_right))","def calc_homogeneity(raw_vr, derived_vr):\n\n vr_bar = np.sum(raw_vr)\n\n return 1 - np.sum((raw_vr - derived_vr) ** 2) / np.sum((raw_vr - vr_bar) ** 2)","def calculate_rho_from_relaxation(self, rvec, drvec=[] ):\n if drvec==[]:\n R1=rvec[0] ; R2=rvec[1] ; NOE=rvec[2]\n HF = -0.2*(self.gX.gamma/self.gH.gamma)*(1-NOE)*R1\n R1p = R1 - 7.0*(0.921/0.87)**2.0*HF\n R2p = R2 - 6.5*(0.955/0.87)**2.0*HF\n return 4.0/3.0*R1p/(2.0*R2p-R1p)\n else:\n R1=rvec[0] ; R2=rvec[1] ; NOE=rvec[2]\n dR1=drvec[0] ; dR2=drvec[1] ; dNOE=drvec[2]\n HF = -0.2*(self.gX.gamma/self.gH.gamma)*(1-NOE)*R1\n R1p = R1 - 7.0*(0.921/0.87)**2.0*HF\n R2p = R2 - 6.5*(0.955/0.87)**2.0*HF\n rho = 4.0/3.0*R1p/(2.0*R2p-R1p)\n drho = 0\n print( \"= = ERROR: drho calculation is not implemented!\" )\n sys.exit(1)\n return (rho, drho)","def convert_reciprocal(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n dtype = infer_type(x).checked_type.dtype\n out = _expr.const(1.0, dtype) / x\n g.add_node(op.output(\"Out\")[0], out)","def gprofile(r,sig,A,B):\n res = A*np.exp(-0.5*(r/sig)**2)+B\n return res","def KD(dG, T = 310):\n return 1 / np.e ** (-dG / (R * T))","def attraction_h(next_r, a):\n if a == 0:\n if next_r == 9:\n return 0.8\n elif next_r == 14:\n return 0.1\n else:\n return 0.1\n\n elif a == 1:\n if next_r == 9:\n return 0.1\n elif next_r == 14:\n return 0.1\n else:\n return 0.8\n\n elif a == 2:\n if next_r == 9:\n return 0.1\n elif next_r == 14:\n return 0.3\n else:\n return 0.6\n\n elif a == 3:\n if next_r == 9:\n return 0.1\n elif next_r == 14:\n return 0.2\n else:\n return 0.7\n\n else:\n if next_r == 9:\n return 0.1\n elif next_r == 14:\n return 0.4\n else:\n return 0.5","def logg(M, R):\n G = c.G.value * 1e3\n M *= c.M_sun.value * 1e3\n R *= c.R_sun.value * 1e2\n return log10(G*M/(R**2))","def denominator(self,gold,length):\n size = length * (length - 1) \n\n gold_size = 0.0\n for lead in gold.keys():\n gold_size += len(gold[lead])\n \n #print 'Whazzup'\n #print gold_size\n #print size\n den1 = gold_size\n den2 = size - gold_size \n #print den1\n #print den2\n return den1/den2","def fun_gauss(p,r):\n return p[1] * np.exp(-((r/p[0])**2))","def le_func(rn, g, h):\n le = np.copy(rn)\n le -= g\n le -= h\n return le","def g(self, x):\n return x * (1 - x)","def _g(self, x):\n e_x = math.exp(-self._alpha * x)\n return (1.0 / (1 + e_x))","def idcg(relevance: np.array, alternate: bool = True) -> float:\n\n if relevance is None or len(relevance) < 1:\n return 0.0\n\n # guard copy before sort\n rel = relevance.copy()\n rel.sort()\n return dcg(rel[::-1], alternate)"],"string":"[\n \"def g(self, RD):\\n g = 1 / np.sqrt((1 + 3 * np.power(self.q, 2)) / np.power(np.pi, 2)) \\n \\n return g\",\n \"def g(r):\\n return np.cos(r) / (np.exp(0.4 * (r - 8)) + 1)\",\n \"def r0(self):\\n return self.p[0] / self.p[1]\",\n \"def get_rm(g):\\n return 1 / g\",\n \"def calculate_gear_ratio(front_gear, back_gear):\\n return front_gear/back_gear\",\n \"def DG(self, n, e, r, f):\\n\\n pre = -e[:, None] + np.divide.outer((n - 1), r)\\n return pre*f\",\n \"def compute_Rg(L):\\n\\treturn np.sqrt(np.dot(L,L))\",\n \"def acc_grav(j,rA,mA,hA,W=kernel.W_M4star):\\n assert rA.shape[0] == mA.shape[0] == hA.shape[0], \\\"arrays are mismatched\\\"\\n N = len(mA)\\n\\n tot = 0\\n for i in range(N):\\n if i != j:\\n\\n r_ij = rA[j,:] - rA[i,:]\\n r_ij1 = np.linalg.norm(r_ij)\\n m_i = mA[i]\\n h_ij = 0.5 * (hA[i] + hA[j])\\n\\n tot += m_i * (r_ij/r_ij**3) * W(r_ij1,h_ij)\\n\\n return - tot * G\",\n \"def g_d(self, z):\\n a = self.g(z)\\n return a * (1 - a)\",\n \"def get_R(R_e,R_h):\\n R = R_e + R_h\\n return R\",\n \"def g(self, r, mu):\\n\\n return np.sqrt(1. - (r / self.R)**2 * (1. - mu**2))\",\n \"def guza2012(H,L,Fw,Ds=1.0):\\n \\n # Make sure parameters are double precision\\n H = np.double(H)\\n L = np.double(L)\\n Fw = np.double(Fw)\\n Ds = np.double(Ds)\\n \\n Fp = (2.0 * np.pi * L / 9.81)**-0.5\\n \\n # Compute R2% IG (Equation 4) \\n r2 = (-0.013 * np.log(Fp/Fw*Ds) + 0.058) * ((H * L)**0.5)\\n \\n return r2\",\n \"def calc_D(state):\\n\\t\\tif t < thresh:\\n\\t\\t\\tstate.D_g[t] = 0.5\\n\\t\\t\\tstate.D_n[t] = 0.5\\n\\t\\telse:\\n\\t\\t\\tif mod == \\\"constant\\\":\\n\\t\\t\\t\\tstate.D_g[t] = D\\n\\t\\t\\t\\tstate.D_n[t] = 1-D\\n\\t\\t\\tif mod == \\\"value\\\":\\n\\t\\t\\t\\t# NOTE: if rmag and lmag is 1/0, can just use V\\n\\t\\t\\t\\t# average of two actions\\n\\t\\t\\t\\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \\n\\t\\t\\t\\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\\n\\t\\t\\t\\tstate.D_g[t] = V \\n\\t\\t\\t\\tstate.D_n[t] = 1 - V\\n\\t\\treturn state\",\n \"def DR(R,Pc):\\n return r1*R*(K1**B1/(K1**B1 + (A/R)**B1))*(S/(S + R*Pc + Pc)) \\\\\\n - gwt*A - r2*R*(K2**B2/(K2**B2 + (A)**B2))*(S/(S + R*Pc + Pc) ) \\\\\\n *(R*M)/(K3 + R*M) + R*gc\",\n \"def G(U):\\n n = U.shape[0]\\n G_U = np.zeros([n,1])\\n DELTA_x = float(2*L)/(n-1)\\n for i in range(n):\\n G_U[i][0] = U[(i+1)%n][0]\\n G_U[i][0] -= U[(i-1)%n][0]\\n G_U[i][0] /= (2* DELTA_x)\\n G_U[i][0] += (float(epsilon) * (U[(i+1)%n][0]- U[(i-1)%n][0]) * (U[(i-1)%n][0]+U[(i+1)%n][0]+ U[i][0])/ (4* DELTA_x))\\n G_U[i][0] += (float(epsilon) * (U[(i+2)%n][0]- 2*U[(i+1)%n][0]+ 2*U[(i-1)%n][0]- U[(i-2)%n][0]) / (12*( DELTA_x**3)))\\n return G_U\",\n \"def g(self, p):\\n re = self._re(p)\\n Le = self._Le(p)\\n wf = self._wf(p)\\n rf = self._rf(p)\\n A = Le @ np.einsum('...ij,...j', self.Ee, re)\\n B = wf @ np.einsum('...ij,...j', self.Ff, rf)\\n return (B - A) * G * self.d\",\n \"def dfr(self):\\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])\",\n \"def reciprocity_ratio(gd):\\r\\n reciprocal = 0.0\\r\\n edge_list = gd.get_edgelist()\\r\\n for i in it.permutations(range(gd.vcount()),2):\\r\\n if i in edge_list and i[::-1] in edge_list:\\r\\n reciprocal += 1.0\\r\\n return reciprocal/gd.ecount()\",\n \"def r_d(self, tl):\\n\\t return self.RD0*exp(self.HKR/(R*self.TO)*(1. - self.TO/tl))\",\n \"def total_potential_energy(R,M,G):\\r\\n U = 0\\r\\n N = R.shape[0] \\r\\n \\r\\n for n in range(N):\\r\\n for nn in range(n+1,N):\\r\\n U = U - G*M[n]*M[nn] / util.enod(R[n,:],R[nn,:])\\r\\n \\r\\n return U\",\n \"def _grads(val, r):\\n return grad(val, r, grad_outputs=torch.ones_like(val))[0]\",\n \"def qr_mgs( A ):\\n\\n A = numpy.array(A, dtype=float)\\n m,n = A.shape\\n Q = numpy.zeros( (m,n) )\\n R = numpy.zeros( (n,n) )\\n\\n for k in range( 0, n ) :\\n R[k,k] = numpy.linalg.norm( A[:,k] )\\n Q[:,k] = A[:,k] / R[k,k]\\n\\n for j in range( k+1, n ) :\\n R[k,j] = numpy.dot( Q[:,k], A[:,j] )\\n A[:,j] = A[:,j] - Q[:,k] * R[k,j]\\n \\n return Q,R\",\n \"def V(E, g, gl):\\n num = 0\\n den = 0\\n for i in range(len(E)):\\n num += E[i][0]*g[i][0] + E[i][1]*g[i][1]\\n den += g[i][0] + g[i][1] + gl\\n return num / den\",\n \"def residualsG(p, data):\\n \\n x, y, err = data\\n return (y-funcG(p,x)) / err\",\n \"def calc_a(dert__):\\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g\",\n \"def R(w,h):\\n\\ta = h/3.0\\n\\tbeta = atan2(a,w)\\n\\tc = sqrt(a**2 + w**2)\\n\\td = c/2.0\\n\\te = d/sin(beta)\\n\\treturn e-a\",\n \"def get_R_h(E, M, l, g_h, T_h):\\n # transform energy-vector into matrices\\n mat_E_x, mat_E_y = np.meshgrid(E,E) \\n mat_diff = mat_E_y - mat_E_x # matrix representing: E_i - E_j\\n \\n # leave out the sine-terms at first\\n R_h = np.ones((M,M))*g_h**2 * T_h*4 # matrix for transition rates\\n ind = np.abs(mat_diff) > 0 # indices of the non-divergent elements\\n # fill in just those elements without divergences 1/0\\n # the rest is set to the correct limit\\n R_h[ind] = g_h**2 *4* mat_diff[ind]/(np.exp(mat_diff[ind]/T_h)-1)\\n \\n # multiply the sine-terms\\n sin = np.sin(l*np.arange(1,M+1)*np.pi/(M+1))**2 # vector with sine-values sin(li)**2\\n # transform sine-vectors into matrices\\n mat_sin_x, mat_sin_y = np.meshgrid(sin,sin)\\n R_h *= mat_sin_x * mat_sin_y\\n \\n return R_h\",\n \"def ga_log(R):\\n phiP, t_normal_n, t_perpendicular_n = extractRotorComponents(R)\\n return phiP + t_normal_n + t_perpendicular_n\",\n \"def h(x, w, r):\\n r = r.unsqueeze(-1)\\n \\n return (r ** 2 - torch.norm(w, dim = -1, keepdim=True) ** 2) / (torch.norm(x - w, dim = -1, keepdim = True) ** 2) * (x - w) - w\",\n \"def density_by_ideal_gas_law(\\n p: tf.Tensor,\\n r: tf.Tensor,\\n t: tf.Tensor,\\n ) -> tf.Tensor:\\n return p / r / t\",\n \"def g_1(self, R, elements):\\n values = numpy.exp(-self.eta * (R - self.r_s) ** 2) * self.f_c(R)\\n numpy.fill_diagonal(values, 0)\\n\\n elements = numpy.array(elements)\\n\\n totals = []\\n for ele in self._elements:\\n idxs = numpy.where(elements == ele)[0]\\n total = values[:, idxs].sum(1)\\n totals.append(total)\\n return numpy.array(totals).T\",\n \"def reciprocal(self):\\n return Rational(self.denominator, self.numerator)\",\n \"def H_G(X):\\n n = X.shape[0]\\n H = np.zeros([n,n])\\n DELTA_x = float(2*L)/(n-1)\\n for i in range(n):\\n H[i][(i-2)%n] = - float(epsilon) / (12 * (DELTA_x**3))\\n H[i][(i-1)%n] = (-2. - float(epsilon) * (X[i][0] + 2*X[(i-1)%n][0])) / (4 * DELTA_x) + 2. * (float(epsilon)/(12*(DELTA_x**3)))\\n H[i][i] = (epsilon * (X[(i+1)%n][0] - X[(i-1)%n][0])) / (4 *DELTA_x)\\n H[i][(i+1)%n] = (2. + float(epsilon) * (X[i][0] + 2*X[(i+1)%n][0])) / (4 * DELTA_x) - 2. * (float(epsilon)/(12*(DELTA_x**3)))\\n H[i][(i+2)%n] = float(epsilon) / (12 * (DELTA_x)**3) \\n return H\",\n \"def sag_ratio(V):\\n\\n Vmin = np.amin(V)\\n Vend = V[-1]\\n sr = (Vmin - Vend) / Vmin\\n if sr < 0:\\n print(\\\"Warning: sag ratio being negative indicates there is no sag\\\")\\n return sr\",\n \"def js_div(d1, d2):\\n part1 = - soft_relu(-d1).mean()\\n part2 = - soft_relu(d2).mean() \\n return part1 + part2 + np.log(4.0)\",\n \"def R(self):\\n\\t\\treturn (arange(self.rbins) + 0.5) * (self.cbins - 0.5) / self.rbins\",\n \"def compute_gae(V, s, ss, r, absorbing, last, gamma, lam):\\n v = V(s)\\n v_next = V(ss)\\n gen_adv = np.empty_like(v)\\n for rev_k in range(len(v)):\\n k = len(v) - rev_k - 1\\n if last[k] or rev_k == 0:\\n gen_adv[k] = r[k] - v[k]\\n if not absorbing[k]:\\n gen_adv[k] += gamma * v_next[k]\\n else:\\n gen_adv[k] = r[k] + gamma * v_next[k] - v[k] + gamma * lam * gen_adv[k + 1]\\n return gen_adv + v, gen_adv\",\n \"def calc_f_g(mu, x, t, ro, inv_a):\\n z = inv_a*pow(x,2)\\n f = 1 - pow(x,2)/ro*stump_C(z) \\n g = t - 1/sqrt(mu)*pow(x,3)*stump_S(z)\\n return f, g\",\n \"def div(f, g):\\n lev, dom, per, F, G = f.unify(g)\\n q, r = dmp_div(F, G, lev, dom)\\n return per(q), per(r)\",\n \"def hr_egn(A, B, R, x0):\\n # A - Adjacency matrix, np.ndarray (N,N)\\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\\n # R - Relationship or preference matrix, np.ndarray (N,N)\\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\\n\\n # Number of players\\n N = A[:, 0].size\\n # Number of strategies\\n S = x0[0, :].size\\n # Degree and degree of preferences\\n d = np.zeros([N, 2])\\n d[:, 0] = np.dot(A, np.ones(N))\\n\\n for v in range(N):\\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\\n\\n # Player v neighborhood\\n k = np.zeros([N, S], dtype='double')\\n for v in range(N):\\n for u in range(N):\\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\\n # Weights the neighborhood\\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\\n\\n # This variable is the increments that x0 receives, the derivative\\n x = np.zeros([N, S], dtype='double')\\n # This is the unit vector with 1 in some entry\\n es = np.zeros(S, dtype='int')\\n\\n # Phi and gamma\\n p = 0\\n g = 0\\n\\n # Auxiliary variables for better clarity\\n aux1 = 0\\n aux2 = 0\\n\\n # Here is the derivative calculation\\n # We first test if all payoffs are the same so we do less comparisons\\n if B.ndim == 2:\\n for v in range(N):\\n for s in range(S):\\n # Set es value\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Same payoff personal equation\\n # First we will do the dot products\\n # e_s*B*k_v\\n aux1 = np.dot(es, np.dot(B, k[v, :]))\\n # x_v*B*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\\n # Finally we subtract them to multiply by r_vv\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Same payoff social equation\\n # x_u*B*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B, es))\\n # x_u*B*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n else:\\n for v in range(N):\\n for s in range(S):\\n # Same thing as before, but now with individual payoffs\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Individual payoffs personal equation\\n # e_s*B_v*k_v\\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\\n # x_u*B_v*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Individual payoffs social equation\\n # x_u*B_u*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\\n # x_u*B_u*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n return x\",\n \"def Rfun(U,V,Q,Phi,Phibar, taudrag):\\n \\n Qclone=Q.copy()\\n Qclone[Q<0]=0\\n\\n Ru=np.divide(np.multiply(-U,Qclone),Phi+Phibar)\\n Rv=np.divide(np.multiply(-V,Qclone),Phi+Phibar)\\n \\n #reset to 0 if losing mass\\n Ru[Q<0]=0\\n Rv[Q<0]=0\\n \\n #if taudrag is infinity, only have the R componen \\n if taudrag!=-1:\\n F=Ru-(U/taudrag)\\n G=Rv-(V/taudrag)\\n \\n else:\\n F=Ru\\n G=Rv\\n \\n return F, G\",\n \"def gru(params, h, x):\\n bfg = 0.5\\n hx = np.concatenate([h, x], axis=0)\\n ru = sigmoid(np.dot(params['wRUHX'], hx) + params['bRU'])\\n r, u = np.split(ru, 2, axis=0)\\n rhx = np.concatenate([r * h, x])\\n c = np.tanh(np.dot(params['wCHX'], rhx) + params['bC'] + bfg)\\n return u * h + (1.0 - u) * c\",\n \"def wer(r, h):\\n #build the matrix\\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8).reshape((len(r)+1, len(h)+1))\\n for i in range(len(r)+1):\\n for j in range(len(h)+1):\\n if i == 0: d[0][j] = j\\n elif j == 0: d[i][0] = i\\n for i in range(1, len(r)+1):\\n for j in range(1, len(h)+1):\\n if r[i-1] == h[j-1]:\\n d[i][j] = d[i-1][j-1]\\n else:\\n substitute = d[i-1][j-1] + 1\\n insert = d[i][j-1] + 1\\n delete = d[i-1][j] + 1\\n d[i][j] = min(substitute, insert, delete)\\n result = float(d[len(r)][len(h)]) / len(r) * 100\\n result = str(\\\"%.2f\\\" % result) + \\\"%\\\"\\n return d[len(r)][len(h)]\\n #find out the manipulation steps\",\n \"def gradh(self,q):\\n gx = self.d_i(q) / self.e1u\\n gy = self.d_j(q) / self.e2v\\n #\\n return gx,gy\",\n \"def reward_function(self):\\r\\n def R(state, decision, nodes):\\r\\n return -1.0/1000*nodes['G'].get_preds_value(state)*(decision['G:R_1']+decision['G:L'])\\r\\n \\r\\n return R\",\n \"def d1(self):\\r\\n numerator = math.log(self.s/self.x) + (self.rf-self.div+self.sigma**2*0.5)*self.t # Numerator of d1\\r\\n denominator = self.sigma * self.t**0.5 # Denominator of d1\\r\\n \\r\\n return numerator/denominator\",\n \"def M_g(self):\\n\\n print(\\\"\\\", file=self.logfile)\\n print(\\\"Updating g\\\", file=self.logfile)\\n M_mu1 = np.lib.stride_tricks.as_strided(self.mu_pad,\\n shape=[self.P+1, self.L_h],\\n strides=[self.mu_pad.strides[-1], self.mu_pad.strides[-1]])\\n\\n M_mu1 = M_mu1[::-1,:]\\n M_mu2 = np.transpose(M_mu1[1:,:])\\n M_mu1 = M_mu1*self.e2\\n\\n M_mu = np.dot(M_mu1, M_mu2)\\n v_mu = M_mu[0,:]\\n M_mu = M_mu[1:,:]\\n\\n M_R = np.zeros((self.P,self.P+1))\\n for p in range(1,self.P+1):\\n for q in range(0,self.P+1):\\n M_R[p-1,q] = np.sum(np.diag(self.R, q-p)[:self.L_h-max(p,q)]*self.e2[max(p,q):self.L_h])\\n\\n v_R = M_R[:,0]\\n M_R = M_R[:,1:]\\n\\n self.alpha_g = np.dot(np.linalg.inv(M_mu + M_R), v_mu+v_R)\\n self.A = np.concatenate([[1], -self.alpha_g])\\n\\n self._propagate_A()\",\n \"def mamajek08_logRpHK_Ro_edge():\\n Ro_edge = 0.31935816876122064\\n return Ro_edge\",\n \"def _gs_step(r: jax.ShapedArray,\\n v_i: jax.ShapedArray) -> Tuple[jax.ShapedArray, jax.ShapedArray]:\\n h_i = jnp.vdot(v_i, r)\\n r_i = r - h_i * v_i\\n return r_i, h_i\",\n \"def solve_R(R, b):\\n n = b.size\\n assert R.shape == (n,n)\\n x = zeros(n, dtype=R.dtype)\\n for i in range(n-1,-1,-1):\\n x[i] = (b[i] - dot(x[i+1:], R[i,i+1:])) / R[i,i]\\n if not numpy.isfinite(x[i]):\\n x[i] = 0.0\\n return x\",\n \"def _gcl(x, r, D, Ia, Ct):\\n\\n Area = np.pi * D ** 2.0 / 4.0\\n m = 1.0 / (np.sqrt(1.0 - Ct))\\n k = np.sqrt((m + 1.0) / 2.0)\\n\\n a1 = 0.435449861 # empirically determined\\n a2 = 0.797853685\\n a3 = -0.124807893\\n a4 = 0.136821858\\n b1 = 15.6298\\n b2 = 1.0\\n R96 = a1 * (np.exp(a2 * Ct * Ct + a3 * Ct + a4)) * (b1 * Ia + b2) * D\\n\\n x0 = (9.6 * D) / ((2.0 * R96 / (k * D)) ** 3.0 - 1.0)\\n term1 = (k * D / 2.0) ** (5.0 / 2.0)\\n term2 = (105.0 / (2.0 * np.pi)) ** (-0.5)\\n term3 = (Ct * Area * x0) ** (-5.0 / 6.0)\\n c1 = term1 * term2 * term3\\n # c45=3*(c1) ** 2\\n\\n term10 = 0.1111 # * WindSpeed # U/9.0\\n term20 = (Ct * Area * (x + x0) ** (-2.0)) ** (1.0 / 3.0)\\n term310 = (r ** (3.0 / 2.0))\\n term320 = (3.0 * c1 * c1 * Ct * Area * (x + x0)) ** (-0.5)\\n term30 = term310 * term320\\n term40 = ((35.0 / (2.0 * np.pi)) ** (3.0 / 10.0)) * \\\\\\n (3.0 * c1 * c1) ** (-1.0 / 5.0)\\n DU1 = -term10 * term20 * (term30 - term40) ** 2.0\\n\\n DU = DU1 # + w2 * DU2\\n Rw = ((105 * c1 ** 2.0 / (2 * np.pi)) ** (1. / 5.)) * \\\\\\n (Ct * Area * (x + x0)) ** (1. / 3.)\\n return DU, Rw\",\n \"def numerator(self,data,gold):\\n gold_size = 0.0\\n for lead in gold.keys():\\n gold_size += len(gold[lead])\\n print gold_size\\n epsilon = 0.0000000001\\n match = 0.0\\n not_match = 0.0\\n exp_size = 0.0\\n for lead in data.keys():\\n for hit in data[lead]:\\n exp_size += 1\\n edge = (lead,hit[0])\\n if self.CompareEdges(edge,gold):\\n print edge\\n match += 1\\n else:\\n not_match += 1\\n\\n if match == 0.0:\\n match = epsilon\\n elif not_match == 0.0:\\n not_match = epsilon\\n print match\\n print not_match\\n num1 = match \\n num2 = not_match\\n return num1/num2\",\n \"def calc_a(r):\\n r3 = np.hypot(*r)**3\\n return -fac * r / r3\",\n \"def gamma(a,b,c,d):\\n g1 = max((c + d) * (1 - b) * b / (c*d * np.math.log(2)), 0.0)\\n g2 = max((c + d) * 21**2 / (c*d * (1 - b) * b*a**2), 1.0)\\n g = np.math.sqrt(g1 * np.math.log(g2, 2))\\n return g\",\n \"def dcg(self, ranking_relevances):\\n return sum([(2 ** relevance - 1) / math.log(rank + 2, 2) for rank, relevance in enumerate(ranking_relevances)])\",\n \"def pollard_rho(g: int, h: int, n: int, order: int = None):\\n x = {0: 1}\\n a = {0: 0}\\n b = {0: 0}\\n\\n import ressources.multGroup as multGroup\\n\\n if order is None:\\n order = multGroup.multiplicativeOrder(g, n)\\n\\n # from a, b and c, partitioning the field\\n def step_xab(x, a, b, g, h, order, n):\\n s = x % 3\\n\\n # S1\\n if s == 1:\\n x = x * h % n\\n b = (b + 1) % order\\n\\n # S2\\n if s == 0:\\n x = square_and_multiply(x, 2, n)\\n a = 2 * a % order\\n b = 2 * b % order\\n\\n # S3\\n if s == 2:\\n x = x * g % n\\n a = (a + 1) % order\\n\\n return x, a, b\\n\\n # returns x, a, b for a given i using memoization\\n def get_xab(i):\\n\\n if i not in x:\\n _x, _a, _b = get_xab(i - 1)\\n\\n x[i], a[i], b[i] = step_xab(_x, _a, _b, g, h, order, n)\\n\\n return x[i], a[i], b[i]\\n\\n def naturals_from(i):\\n while True:\\n # yield is a keyword that is used like return, except the function will return a generator.\\n # https://www.google.com/search?client=firefox-b-d&q=yield+python\\n yield i\\n i += 1\\n\\n for i in naturals_from(1):\\n\\n x_i, a_i, b_i = get_xab(i)\\n x_2i, a_2i, b_2i = get_xab(2 * i)\\n\\n if x_i == x_2i:\\n\\n r = (b_i - b_2i) % order\\n\\n if r == 0:\\n return False\\n\\n return multGroup.inv(r, order) * (a_2i - a_i) % order\",\n \"def getR(self):\\n # Reynolds number uses the absolute value of the velocity\\n V = abs(self.V)\\n return (V * self.D) / self.v # formula for Reynolds number\",\n \"def __rdiv__(self, other):\\n return self.__rtruediv__(other)\",\n \"def Re(self, rho, u, d_p, mu):\\n return rho*u*d_p/mu\",\n \"def G_core(self, r, b=-1):\\n return self.from_G_charges_and_quotient(self.G_charges(r,b), quotient=None, r=r, b=b)\",\n \"def g(x):\\n return 5. - x[:, 1] - .5 * x[:, 0] ** 2.\",\n \"def calc_V(A):\\n return 1. / calc_rV(A)\",\n \"def dense_gammaln_ratio(x, weights, deriv=0):\\n if deriv == 0:\\n func = gammaln\\n elif deriv == 1:\\n func = digamma\\n else:\\n raise NotImplementedError('Only derivatives up to first order supported')\\n counts = np.where(weights)[0]\\n weights = weights[counts]\\n return func(x[:, None] + counts[None, :]).dot(weights) - func(x) * weights.sum()\",\n \"def acceleration(R,M,G):\\r\\n N = R.shape[0]\\r\\n a = np.zeros((N,3)) # initialize accelerations\\r\\n for n in range(N):\\r\\n for nn in range(N):\\r\\n if n!=nn:\\r\\n a[n,:] += G*M[nn] * (R[nn,:]-R[n,:]) / util.enod(R[nn,:],R[n,:])**(3) \\r\\n return a\",\n \"def pdiv(f, g):\\n lev, dom, per, F, G = f.unify(g)\\n q, r = dmp_pdiv(F, G, lev, dom)\\n return per(q), per(r)\",\n \"def DDG(self, n, e, r, f):\\n pre = (-e[:, None] + np.divide.outer((n - 1), r))**2\\n pre -= np.divide.outer((n - 1), r**2)\\n return pre*f\",\n \"def\\tfOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw):\\n\\tSum=Vc1+Vc2+Vc3+Vk+Vrw\\n\\tOrmGDen=(Vc1*Dc1+Vc2*Dc2+Vc3*Dc3+Vk*Dk+Vrw*Dw)/Sum\\n\\treturn OrmGDen\",\n \"def g(self, X):\\n\\n return (X[0])**2 - 2*X[0] + X[1]**3 - 2\",\n \"def dcg(self, ranking):\\n return sum([(2**r-1)/math.log(i+2,2) for i,r in enumerate(ranking)])\",\n \"def _h(W):\\r\\n # E = slin.expm(W * W)\\r\\n # h = np.trace(E) - d\\r\\n M = np.eye(d) + W * W / d\\r\\n E = np.linalg.matrix_power(M, d - 1)\\r\\n h = (E.T * M).sum() - d\\r\\n G_h = E.T * W * 2\\r\\n return h, G_h\",\n \"def calc_rV(A):\\n return np.sqrt(calc_rVsq(A))\",\n \"def photon_fraction(r, r1, r2):\\n return rotate_phasor(r, r1, r2).real\",\n \"def dcg(relevances, rank=10):\\n relevances = np.asarray(relevances)[:rank]\\n n_relevances = len(relevances)\\n if n_relevances == 0:\\n return 0.\\n\\n discounts = np.log2(np.arange(n_relevances) + 2)\\n return np.sum(relevances / discounts)\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def r_pgh(self, sigma, delta_c, f_nl):\\n\\n if (f_nl < 0):\\n \\n f_nl = abs(f_nl)\\n\\n delta_c = sqrt(0.837)*delta_c #Tinker / sph. collapse correction factor.\\n\\n nu = delta_c / sigma\\n pgh_ng=0.e0\\n e_1 = 3.e-4 * f_nl\\n\\n pgh_ng = sqrt(1.e0/( 1 + e_1*nu )) * exp( (nu*nu/2.e0) + (1/(e_1*e_1))*( e_1*nu - (1+e_1*nu)*log(1+e_1*nu) ) )\\n\\n return 1.e0/pgh_ng\\n\\n elif (f_nl == 0):\\n return 1.e0\\n else:\\n \\n delta_c = sqrt(0.837)*delta_c #Tinker / sph. collapse correction factor.\\n\\n nu = delta_c / sigma\\n pgh_ng=0.e0\\n e_1 = 3.e-4 * f_nl\\n\\n pgh_ng = sqrt(1.e0/( 1 + e_1*nu )) * exp( (nu*nu/2.e0) + (1/(e_1*e_1))*( e_1*nu - (1+e_1*nu)*log(1+e_1*nu) ) )\\n\\n return pgh_ng\",\n \"def do_dr(r, t):\\n return 1/t**0.5\",\n \"def H(x, X, Y, dY):\\n\\n def L(i):\\n #return p[i] * (x ** i)\\n p = [(x - X[i]) / (X[j] - X[i]) for j in range(n) if j != i]\\n return reduce(op.mul, p)\\n\\n def dL(i):\\n #return d[i-1] * (x ** (i-1))\\n if i < n-1:\\n return (Y[i+1] - Y[i]) / (X[i+1] - X[i])\\n else:\\n return (Y[i] - Y[i-1]) / (X[i] - X[i-1])\\n\\n def A(i):\\n return (1 - 2 * (x - X[i]) * dL(i)) * (L(i) ** 2)\\n\\n def B(i):\\n return (x - X[i]) * (L(i) ** 2)\\n\\n assert(len(X) != 0 and len(X) == len(Y)), 'Quantidade de valores em X e Y diferentes'\\n n = len(X)\\n #p = interpolate.lagrange(X, Y)\\n #d = polyder(p)\\n h1 = sum(A(i) * Y[i] for i in range(n))\\n h2 = sum(B(i) * dY[i] for i in range(n))\\n return h1 + h2\",\n \"def expected_g(self):\\n raise NotImplementedError()\\n # \\\\sum_{b} \\\\gamma_b\\n trm2 = self.mf_gamma.sum(axis=2)\\n E_g = self.mf_gamma / trm2[:,:,None]\\n return E_g\",\n \"def get_rel_residuals(dfr, var):\\n gen_var = 'gen_' + var\\n return (dfr.loc[:, var] - dfr.loc[:, gen_var]) / dfr.loc[:, gen_var]\",\n \"def mapd(self) -> float:\\n a = np.sum(np.abs(self.predicted - self.true))\\n b = np.sum(np.abs(self.true))\\n return float(a / b)\",\n \"def fun_lorentzian_p_gauss(p,r):\\n return p[1] / ((r/p[0])**2 + 1) + p[2] * np.exp(-((r/p[0])**2)/2)\",\n \"def xgcd(self, a):\\n s, old_s = [0], [1]\\n t, old_t = [1], [0]\\n r, old_r = self.coef, a\\n\\n while sum(r) != 0:\\n quotient = self.poly_round_div(old_r, r)\\n old_r, r = r, [sum(x) % self.mod for x in\\n itertools.zip_longest(old_r, [x * (-1) for x in self._mul_coef(quotient, r)], fillvalue=0)]\\n old_s, s = s, [sum(x) % self.mod for x in\\n itertools.zip_longest(old_s, [x * (-1) for x in self._mul_coef(quotient, s)], fillvalue=0)]\\n old_t, t = t, [sum(x) % self.mod for x in\\n itertools.zip_longest(old_t, [x * (-1) for x in self._mul_coef(quotient, t)], fillvalue=0)]\\n while len(r) and r[-1] == 0:\\n r.pop()\\n return old_r, old_s, old_t\\n # # old_r[0]이 1이 아닌경우는 old_r[0]으로 나눠야 한다.\\n # old_s_inv = mul_inverse_mod(old_r[0], self.mod)\\n # # result = [ x % 3 for x in self.poly_mul2(old_s, [old_s_inv])]\\n # result = [x % self.mod for x in self._mul_coef(old_s, [old_s_inv])]\\n # return result + ([0] * (len(self.irr_coef) - len(result)))\",\n \"def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\\n ratio_x = 0\\n ratio_y = 0\\n ratio_z = 0\\n # helm_B = [0,0,0]\\n divideby = 0\\n for shot in range(shot_range[0], shot_range[1]+1):\\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\\n ratio_x = ratio_x + x\\n ratio_y = ratio_y + y\\n ratio_z = ratio_z + z\\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\\n divideby = divideby + 1 #averaging over the number of shots\\n ratio_Bx = ratio_x/divideby\\n ratio_By = ratio_y/divideby\\n ratio_Bz = ratio_z/divideby\\n # helmB = [helm_B]/divideby\\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\\n # print(\\\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\\\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\\n Bx_sqr =ratio_x**2\\n By_sqr =ratio_y**2\\n Bz_sqr =ratio_z**2\\n B = Bx_sqr + By_sqr+ Bz_sqr\\n norm_factor = np.sqrt(B)\\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\\n\\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)\",\n \"def _get_A_rdm(self, p):\\n\\n return rdm_graph(self.G, nodelist=self.nodelist, percent=p)\",\n \"def rh(self, h):\\n sez=self.getSect(h)\\n area=self.area(sez)\\n wetborder = self.wetBorder(sez)\\n return area/wetborder\",\n \"def cache_gH(self):\\n self.gH.fill(0.)\\n for lag, Wl in enumerate(self.W):\\n self.gH += s_dot(Wl.T, self.resids, -lag)\\n return self.gH\",\n \"def retarded_gf(h_ao, s_ao, energy, gamma_left, gamma_right):\\n return np.linalg.inv(energy*s_ao - h_ao + (1j/2.)*(gamma_left + gamma_right))\",\n \"def calc_homogeneity(raw_vr, derived_vr):\\n\\n vr_bar = np.sum(raw_vr)\\n\\n return 1 - np.sum((raw_vr - derived_vr) ** 2) / np.sum((raw_vr - vr_bar) ** 2)\",\n \"def calculate_rho_from_relaxation(self, rvec, drvec=[] ):\\n if drvec==[]:\\n R1=rvec[0] ; R2=rvec[1] ; NOE=rvec[2]\\n HF = -0.2*(self.gX.gamma/self.gH.gamma)*(1-NOE)*R1\\n R1p = R1 - 7.0*(0.921/0.87)**2.0*HF\\n R2p = R2 - 6.5*(0.955/0.87)**2.0*HF\\n return 4.0/3.0*R1p/(2.0*R2p-R1p)\\n else:\\n R1=rvec[0] ; R2=rvec[1] ; NOE=rvec[2]\\n dR1=drvec[0] ; dR2=drvec[1] ; dNOE=drvec[2]\\n HF = -0.2*(self.gX.gamma/self.gH.gamma)*(1-NOE)*R1\\n R1p = R1 - 7.0*(0.921/0.87)**2.0*HF\\n R2p = R2 - 6.5*(0.955/0.87)**2.0*HF\\n rho = 4.0/3.0*R1p/(2.0*R2p-R1p)\\n drho = 0\\n print( \\\"= = ERROR: drho calculation is not implemented!\\\" )\\n sys.exit(1)\\n return (rho, drho)\",\n \"def convert_reciprocal(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n dtype = infer_type(x).checked_type.dtype\\n out = _expr.const(1.0, dtype) / x\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def gprofile(r,sig,A,B):\\n res = A*np.exp(-0.5*(r/sig)**2)+B\\n return res\",\n \"def KD(dG, T = 310):\\n return 1 / np.e ** (-dG / (R * T))\",\n \"def attraction_h(next_r, a):\\n if a == 0:\\n if next_r == 9:\\n return 0.8\\n elif next_r == 14:\\n return 0.1\\n else:\\n return 0.1\\n\\n elif a == 1:\\n if next_r == 9:\\n return 0.1\\n elif next_r == 14:\\n return 0.1\\n else:\\n return 0.8\\n\\n elif a == 2:\\n if next_r == 9:\\n return 0.1\\n elif next_r == 14:\\n return 0.3\\n else:\\n return 0.6\\n\\n elif a == 3:\\n if next_r == 9:\\n return 0.1\\n elif next_r == 14:\\n return 0.2\\n else:\\n return 0.7\\n\\n else:\\n if next_r == 9:\\n return 0.1\\n elif next_r == 14:\\n return 0.4\\n else:\\n return 0.5\",\n \"def logg(M, R):\\n G = c.G.value * 1e3\\n M *= c.M_sun.value * 1e3\\n R *= c.R_sun.value * 1e2\\n return log10(G*M/(R**2))\",\n \"def denominator(self,gold,length):\\n size = length * (length - 1) \\n\\n gold_size = 0.0\\n for lead in gold.keys():\\n gold_size += len(gold[lead])\\n \\n #print 'Whazzup'\\n #print gold_size\\n #print size\\n den1 = gold_size\\n den2 = size - gold_size \\n #print den1\\n #print den2\\n return den1/den2\",\n \"def fun_gauss(p,r):\\n return p[1] * np.exp(-((r/p[0])**2))\",\n \"def le_func(rn, g, h):\\n le = np.copy(rn)\\n le -= g\\n le -= h\\n return le\",\n \"def g(self, x):\\n return x * (1 - x)\",\n \"def _g(self, x):\\n e_x = math.exp(-self._alpha * x)\\n return (1.0 / (1 + e_x))\",\n \"def idcg(relevance: np.array, alternate: bool = True) -> float:\\n\\n if relevance is None or len(relevance) < 1:\\n return 0.0\\n\\n # guard copy before sort\\n rel = relevance.copy()\\n rel.sort()\\n return dcg(rel[::-1], alternate)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65369403","0.6507665","0.6253428","0.6249482","0.6246978","0.6144162","0.6086388","0.608423","0.6083159","0.60784787","0.60262895","0.5952174","0.5915985","0.5905272","0.5902779","0.5874937","0.5870388","0.58570063","0.5824216","0.582396","0.58188695","0.58157253","0.5784628","0.578357","0.57634336","0.57465863","0.57450247","0.5708765","0.56738544","0.5669711","0.5653545","0.5651019","0.5645088","0.5644739","0.5615522","0.5609063","0.56023884","0.56010956","0.5594795","0.5572499","0.55715656","0.5565552","0.55517465","0.5548165","0.5535022","0.5534195","0.55340385","0.55332047","0.552951","0.55261177","0.5523439","0.5518938","0.5517952","0.5515639","0.5497983","0.54879516","0.5486489","0.54802805","0.54800224","0.5478778","0.5473166","0.547246","0.5456096","0.54543173","0.5452424","0.5450376","0.5444074","0.54392314","0.5438757","0.54351836","0.5427668","0.54254955","0.5415876","0.54133034","0.5409113","0.5408989","0.5408713","0.54032755","0.5401288","0.5383178","0.53788084","0.53742427","0.53716606","0.5356096","0.53556913","0.5350352","0.53459907","0.5345383","0.5342629","0.53378206","0.532391","0.5311283","0.53057575","0.5295178","0.5292747","0.52923906","0.52853894","0.52842665","0.5280348","0.52780664"],"string":"[\n \"0.65369403\",\n \"0.6507665\",\n \"0.6253428\",\n \"0.6249482\",\n \"0.6246978\",\n \"0.6144162\",\n \"0.6086388\",\n \"0.608423\",\n \"0.6083159\",\n \"0.60784787\",\n \"0.60262895\",\n \"0.5952174\",\n \"0.5915985\",\n \"0.5905272\",\n \"0.5902779\",\n \"0.5874937\",\n \"0.5870388\",\n \"0.58570063\",\n \"0.5824216\",\n \"0.582396\",\n \"0.58188695\",\n \"0.58157253\",\n \"0.5784628\",\n \"0.578357\",\n \"0.57634336\",\n \"0.57465863\",\n \"0.57450247\",\n \"0.5708765\",\n \"0.56738544\",\n \"0.5669711\",\n \"0.5653545\",\n \"0.5651019\",\n \"0.5645088\",\n \"0.5644739\",\n \"0.5615522\",\n \"0.5609063\",\n \"0.56023884\",\n \"0.56010956\",\n \"0.5594795\",\n \"0.5572499\",\n \"0.55715656\",\n \"0.5565552\",\n \"0.55517465\",\n \"0.5548165\",\n \"0.5535022\",\n \"0.5534195\",\n \"0.55340385\",\n \"0.55332047\",\n \"0.552951\",\n \"0.55261177\",\n \"0.5523439\",\n \"0.5518938\",\n \"0.5517952\",\n \"0.5515639\",\n \"0.5497983\",\n \"0.54879516\",\n \"0.5486489\",\n \"0.54802805\",\n \"0.54800224\",\n \"0.5478778\",\n \"0.5473166\",\n \"0.547246\",\n \"0.5456096\",\n \"0.54543173\",\n \"0.5452424\",\n \"0.5450376\",\n \"0.5444074\",\n \"0.54392314\",\n \"0.5438757\",\n \"0.54351836\",\n \"0.5427668\",\n \"0.54254955\",\n \"0.5415876\",\n \"0.54133034\",\n \"0.5409113\",\n \"0.5408989\",\n \"0.5408713\",\n \"0.54032755\",\n \"0.5401288\",\n \"0.5383178\",\n \"0.53788084\",\n \"0.53742427\",\n \"0.53716606\",\n \"0.5356096\",\n \"0.53556913\",\n \"0.5350352\",\n \"0.53459907\",\n \"0.5345383\",\n \"0.5342629\",\n \"0.53378206\",\n \"0.532391\",\n \"0.5311283\",\n \"0.53057575\",\n \"0.5295178\",\n \"0.5292747\",\n \"0.52923906\",\n \"0.52853894\",\n \"0.52842665\",\n \"0.5280348\",\n \"0.52780664\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5556284"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":9457,"cells":{"query":{"kind":"string","value":"Build Data Docs for a project."},"document":{"kind":"string","value":"def docs_build(directory, site_name, view=True, assume_yes=False):\n context = toolkit.load_data_context_with_error_handling(directory)\n build_docs(context, site_name=site_name, view=view, assume_yes=assume_yes)\n toolkit.send_usage_message(\n data_context=context, event=\"cli.docs.build\", success=True\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 generate_documentation(self):\n self.generate_api_docs()\n build.main([\n self.SOURCE_DIR,\n self.BUILD_DIR,\n ])","def build_docs(context, site_name=None, view=True, assume_yes=False):\n logger.debug(\"Starting cli.datasource.build_docs\")\n\n if site_name is not None:\n site_names = [site_name]\n else:\n site_names = None\n index_page_locator_infos = context.build_data_docs(\n site_names=site_names, dry_run=True\n )\n\n msg = \"\\nThe following Data Docs sites will be built:\\n\\n\"\n for site_name, index_page_locator_info in index_page_locator_infos.items():\n msg += \" - <cyan>{}:</cyan> \".format(site_name)\n msg += \"{}\\n\".format(index_page_locator_info)\n\n cli_message(msg)\n if not assume_yes:\n toolkit.confirm_proceed_or_exit()\n\n cli_message(\"\\nBuilding Data Docs...\\n\")\n context.build_data_docs(site_names=site_names)\n\n cli_message(\"Done building Data Docs\")\n\n if view:\n context.open_data_docs(site_name=site_name, only_if_exists=True)","def buildDocumentation():\n helptext = 'usage: build_doc.py <output format> <type of documentation>' \\\n '\\n - html: for html output' \\\n '\\n - pdf: for pdf output' \\\n '\\n\\n - all: complete documentation' \\\n '\\n - dev: only developer documentation' \\\n '\\n - user: only user documentation'\n if len(sys.argv) != 3:\n print helptext\n sys.exit(1)\n\n if sys.argv[1] not in ['pdf', 'html']:\n print helptext\n sys.exit(1)\n if sys.argv[2] not in ['all', 'dev', 'user']:\n print helptext\n sys.exit(1)\n\n copyfile('docs/index_%s.rst.template' % sys.argv[2], 'index.rst') # copy main file into root directory\n os.system('sphinx-build -b %s -c docs -D master_doc=index . docs/output/%s/%s' % (sys.argv[1], sys.argv[1], sys.argv[2]))\n os.remove('index.rst') # delete config file from root directory","def build():\n\tconsole = Console()\n\tconsole.clear()\n\tconsole.print(BANNER)\n\tif not os.path.exists(\"dataset.yaml\"):\n\t\tclick.clear()\n\t\tconsole.print(\"Dataset config file not found\\nRun - idt init\\n\")\n\t\texit(0)\n\n\twith open('dataset.yaml') as f:\n\t\tdata = yaml.load(f, Loader=yaml.FullLoader)\n\t\n\tclick.clear()\n\tconsole.print(\"Building [bold blue]{dataset_name}[/bold blue] dataset...\\n\".format(dataset_name=data['DATASET_NAME']))\n\tfor classes in data['CLASSES']:\n\t\tclick.clear()\n\t\tconsole.print('Creating [bold blue]{name} class[/bold blue] \\n'.format(name=classes['CLASS_NAME']))\n\t\tsearch_list = classes['SEARCH_KEYWORDS'].split(\",\")\n\t\tfor keywords in search_list:\n\t\t\tfactory = SearchEngineFactory(keywords,data['SAMPLES_PER_SEARCH'],classes['CLASS_NAME'],data['RESIZE_METHOD'], data['DATASET_NAME'],data['IMAGE_SIZE'], data['ENGINE'],data['API_KEY'])\n\t# Remove corrupt files\n\tremove_corrupt(data['DATASET_NAME'])\n\n\t# Create a CSV with dataset info\n\tcreate_dataset_csv(data['DATASET_NAME'])\n\tclick.clear()\n\tconsole.print(\"Dataset READY!\")","def run():\n build_no_documentation()\n build_sphinx_build()\n #build_sphinx_pdf()\n build_graphviz_files()","def build_docs(source, destination, doctrees):\n sphinx_argv = [\n '-b', 'html',\n '-d', doctrees,\n source,\n destination]\n\n sphinx_main(['sphinx-build'] + sphinx_argv)","def main():\n # We know that qidoc build will set the correct cwd\n qibuild_dir = \"..\"\n qibuild_dir = os.path.abspath(qibuild_dir)\n this_file = __file__\n this_dir = os.path.dirname(this_file)\n cmake_api = os.path.join(this_dir, \"../source/advanced/cmake/api\")\n cmake_api = os.path.abspath(cmake_api)\n if not os.path.exists(cmake_api):\n os.makedirs(cmake_api)\n qibuild_cmake = os.path.join(qibuild_dir, \"cmake\", \"qibuild\")\n for filename in DOCUMENTED_FILES:\n cmake_file = os.path.join(qibuild_cmake, filename + \".cmake\")\n rst_file = os.path.join(cmake_api, filename + \".rst\")\n gen_cmake_doc(cmake_file, rst_file)","def build_docs(open_docs):\n python_call(\"pip\", [\"install\", \"src/[docs]\"])\n python_call(\"pip\", [\"install\", \"-r\", \"src/requirements.txt\"])\n python_call(\n \"ipykernel\", [\"install\", \"--user\", \"--name=za_covid_map\"]\n )\n shutil.rmtree(\"docs/build\", ignore_errors=True)\n call(\n [\n \"sphinx-apidoc\",\n \"--module-first\",\n \"-o\",\n \"docs/source\",\n \"src/za_covid_map\",\n ]\n )\n call([\"sphinx-build\", \"-M\", \"html\", \"docs/source\", \"docs/build\", \"-a\"])\n if open_docs:\n docs_page = (Path.cwd() / \"docs\" / \"build\" / \"html\" / \"index.html\").as_uri()\n secho(\"Opening {}\".format(docs_page))\n webbrowser.open(docs_page)","def project():","def project():","def project():","def build():","def build_documents(self, *args, **kwargs):\n docs_manager = self._documents_manager\n resources_tree = self._resources_manager.resources_tree\n return docs_manager.build_documents(resources_tree, *args, **kwargs)","def build_data(self):\n\n _header_ = self._header_ + 'build_data(): '\n\n if self.verbose:\n print(_header_ + 'Building data for %s ...' % self.p_data)\n\n self.read_data()\n self.map_data()\n self.partition_data()\n self.composition()\n\n if self.verbose:\n print(_header_ + 'Build complete.')\n\n return self","def build_docs():\n docs = []\n for base_id in range(DOCUMENTS_PER_LEVEL):\n d = jina_pb2.Document()\n d.granularity = 0\n d.adjacency = 0\n d.id = base_id\n docs.append(d)\n iterate_build(d, 0, 2, 0, 2)\n return docs","def copy_project_docs(srctree):\n docdir = os.path.join(srctree, 'Doc')\n\n # This block shouldn't be here, but I do not yet know how to\n # embed this in ReST files.\n extra_info = {}\n if os.path.exists(os.path.join(docdir, 'website.lst')):\n fd = open(os.path.join(docdir, 'website.lst'))\n for ln in fd.readlines():\n if ln.startswith('#'): continue\n fields = ln.split(',')\n extra_info[fields[0].strip()] = {\n 'section': fields[1].strip(),\n 'priority': int(fields[2].strip()),\n }\n\n docs = [ os.path.join(docdir, fn)\n for fn in os.listdir(docdir) if fn.endswith('.txt') ]\n docs.append(os.path.join(srctree, 'Install.txt'))\n docs.append(os.path.join(srctree, 'NEWS.txt'))\n docs.append(os.path.join(docdir, 'tutorial', 'tutorial.txt'))\n docs.append(os.path.join(docdir, 'tutorial_embed', 'extending_objc_with_python.txt'))\n NAMES = {\n os.path.join(srctree, 'Examples', '00ReadMe.txt') : 'Examples.txt',\n }\n docs.extend(NAMES)\n\n alldocs = {}\n\n for fname in docs:\n print \"-\", fname\n docinfo = {}\n\n bn = NAMES.get(fname)\n if bn is None:\n bn = os.path.split(fname)[-1]\n if bn in ('index.txt', 'announcement.txt'):\n continue\n if extra_info.has_key(bn):\n docinfo.update(extra_info[bn])\n\n if bn.endswith('.txt'):\n bn = bn[:-3].lower() + \"php\"\n else:\n bn = bn.lower() + '.php'\n fd = open(fname)\n input = fd.read()\n fd.close()\n output = docutils.core.publish_string(\n source = input,\n source_path = fname,\n destination_path = bn,\n writer_name = 'hthtml')\n \n output_lines = output.split('\\n')\n for i in range(len(output_lines)):\n if output_lines[i] == '':\n break\n idx = output_lines[i].find(':')\n if idx == -1:\n break\n\n key = output_lines[i][:idx].strip()\n value = output_lines[i][idx+1:].strip()\n docinfo[key] = value\n\n output = '\\n'.join(output_lines[i:])\n if not docinfo.has_key('title'):\n docinfo['title'] = bn\n alldocs[bn] = docinfo\n \n fd = open(os.path.join('docroot', 'doc', bn), 'w')\n fd.write(PHP_HEADER%docinfo)\n\n fd.write(output);\n\n fd.write(PHP_FOOTER)\n\n # Calculate indices for user and developer documentation\n docs = alldocs.keys()\n developer_docs = []\n user_docs = []\n\n for doc in alldocs:\n if not alldocs[doc].has_key('section'):\n print \"Skipping\", doc\n continue\n\n if alldocs[doc]['section'] == 'user':\n user_docs.append([alldocs[doc]['title'], doc])\n elif alldocs[doc]['section'] == 'developer':\n developer_docs.append([alldocs[doc]['title'], doc])\n\n def doccmp(a, b):\n r = cmp(alldocs[a[1]]['priority'], alldocs[b[1]]['priority'])\n if r != 0: return r\n\n return cmp(a[1], b[1])\n user_docs.sort(doccmp)\n developer_docs.sort(doccmp)\n \n # Rewrite the indices (substitute the current document lists)\n for fname in ('index.php', 'usage.php', 'developer.php'):\n fd = open(os.path.join('docroot', 'doc', fname), 'r')\n index_php = fd.readlines()\n fd.close()\n\n fd = open(os.path.join('docroot', 'doc', fname), 'w')\n skip = 0\n for ln in index_php:\n if not skip:\n fd.write(ln)\n if ln.find('/USERDOC') != -1:\n skip = 0\n fd.write(ln)\n elif ln.find('USERDOC') != -1:\n skip = 1\n for title, link in user_docs:\n fd.write('<LI><A HREF=\"%s\">%s</A>\\n'%(link, title))\n if ln.find('/DEVDOC') != -1:\n skip = 0\n fd.write(ln)\n elif ln.find('DEVDOC') != -1:\n skip = 1\n for title, link in developer_docs:\n fd.write('<LI><A HREF=\"%s\">%s</A>\\n'%(link, title))\n\n EXAMPLES = os.path.join('docroot', 'doc', 'examples.php')\n OUTEXAMPLES = os.path.join('docroot', 'examples', 'index.php')\n replace_examples_svn(EXAMPLES)\n if os.path.exists(OUTEXAMPLES):\n os.unlink(OUTEXAMPLES)\n shutil.copyfile(EXAMPLES, OUTEXAMPLES)\n\n # Copy tutorial files\n TUTORIAL_ENDINGS = ['.nib', '.py', '-src', '.h', '.m']\n tutdir = os.path.join(docdir, 'tutorial')\n files = os.listdir(tutdir)\n replacements = []\n for fn in files:\n for ext in TUTORIAL_ENDINGS:\n if fn.endswith(ext):\n dstname = os.path.join('docroot', 'doc', fn)\n replacements.append(copy_tutorial_file(fn, tutdir, dstname))\n break\n replace_tutorial_zips(os.path.join('docroot', 'doc', 'tutorial.php'), replacements)\n \n tutdir = os.path.join(docdir, 'tutorial_embed', 'src')\n files = os.listdir(tutdir)\n if not os.path.exists(os.path.join('docroot', 'doc', 'src')):\n os.mkdir(os.path.join('docroot', 'doc', 'src'))\n for fn in files:\n for ext in TUTORIAL_ENDINGS:\n if fn.endswith(ext):\n dstname = os.path.join('docroot', 'doc', 'src', fn)\n replacements.append(copy_tutorial_file(fn, tutdir, dstname))\n break\n replace_tutorial_zips(os.path.join('docroot', 'doc', 'tutorial.php'), replacements)\n\n #print \"Don't forget to update docroot/doc/tutorial.php: it's references to\"\n #print \"'step3-MainMenu.nib' and 'step12-src' should be changed to ZIP files\"","def _sphinx_build(self, kind: str):\n if kind not in (\"html\", \"latex\"):\n raise ValueError(f\"kind must be html or latex, not {kind}\")\n\n cmd = [\"sphinx-build\", \"-b\", kind]\n if self.num_jobs:\n cmd += [\"-j\", self.num_jobs]\n if self.warnings_are_errors:\n cmd += [\"-W\", \"--keep-going\"]\n if self.verbosity:\n cmd.append(f\"-{'v' * self.verbosity}\")\n cmd += [\n \"-d\",\n os.path.join(BUILD_PATH, \"doctrees\"),\n SOURCE_PATH,\n os.path.join(BUILD_PATH, kind),\n ]\n return subprocess.call(cmd)","def _sphinx_build(self, kind: str):\n if kind not in (\"html\", \"latex\"):\n raise ValueError(f\"kind must be html or latex, not {kind}\")\n\n cmd = [\"sphinx-build\", \"-b\", kind]\n if self.num_jobs:\n cmd += [\"-j\", self.num_jobs]\n if self.warnings_are_errors:\n cmd += [\"-W\", \"--keep-going\"]\n if self.verbosity:\n cmd.append(f\"-{'v' * self.verbosity}\")\n cmd += [\n \"-d\",\n os.path.join(BUILD_PATH, \"doctrees\"),\n SOURCE_PATH,\n os.path.join(BUILD_PATH, kind),\n ]\n return subprocess.call(cmd)","def doc(self):\n from distutils.dir_util import copy_tree\n\n def copy_tree_checker(src, dst):\n \"\"\"Wrap copy_tree to avoid pydoit error.\"\"\"\n copy_tree(src, dst)\n return True\n\n return {\n \"actions\": [\n (create_dir, [\"build/doc/source\"]),\n (copy_tree_checker, [\"docs\", \"build/doc/source\"]),\n TaskCreator.get_sphinx() + \"-apidoc -o build/doc/source --force --separate --module-first \" + self.project_name_sc,\n TaskCreator.get_sphinx() + \"-build -j auto -n build/doc/source build/doc/html\"\n ],\n \"verbosity\": 2\n }","def build_document(self):\n pass","def createFakeSphinxProject(self):\n self.sourceDir.child(\"conf.py\").setContent(self.confContent.encode())\n self.sourceDir.child(\"index.rst\").setContent(self.indexContent.encode())","def getProjectData(self) -> ghidra.framework.model.ProjectData:\n ...","def docs():\n sh('sphinx-build -W -b html docs docs/_build/html')","def makeDocFile(self):\n\n f_out = \"%s/%s-doc.php\" % (self.dir_out, self.project_id)\n version = max(self.versions)\n\n with open(f_out, 'w') as f:\n f.write(\"<!DOCTYPE html>\\n\" \\\n \"<html xmlns=\\\"http://www.w3.org/1999/xhtml\\\">\\n\" \\\n \"<head>\\n\" \\\n \"<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n\" \\\n \"\\n\" \\\n \"<title>Kit&Pack − Ultimate Power Booster</title>\\n\" \\\n \"<link rel=\\\"shortcut icon\\\" type=\\\"image/png\\\" href=\\\"../favicon.png\\\"/>\" \\\n \"<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"../css/doc-2.css\\\" />\\n\"\n \"\\n\" \\\n \"</head>\\n\" \\\n \"<body>\\n\" \\\n \"\\n\" \\\n \"<h1>Ultimate Power Booster</h1>\" \\\n \"\\n\")\n\n # Write a list of other versions of the documentation\n f.write(\"<p>Versions de cette documentation.</p>\\n\")\n f.write(\"<ul>\\n\")\n for v in self.versions:\n f.write(\"\\t<li><a href=\\\"%s.php\\\">%s</a></li>\\n\" % (\n v, v))\n f.write(\"</ul>\\n\\n\")\n\n f.write(\"<?php\\n\" \\\n \"include(\\\"%s.php\\\")\\n\" \\\n \"?>\\n\" \\\n \"\\n\" \\\n \"</body>\\n\" \\\n \"</html>\" % (version))","def generate_build_document(self, commit_info, manifest_info):\n\n manifest_path, commit = commit_info\n build_name = manifest_info.name\n logging.info(f'Generating build document for manifest {build_name}...')\n\n # See if build document already is in the database and extract\n # for updating if so, otherwise create a new dictionary for\n # population\n try:\n build_data = self.db.get_document(build_name)\n except cbdatabase_db.NotFoundError:\n build_data = dict(type='build', key_=build_name)\n\n projects = dict()\n\n for project_name in manifest_info.get_projects():\n project_shas = manifest_info.get_project_shas(\n project_name\n )\n projects[project_name] = [\n f'{project_name}-{sha}' for sha in project_shas\n ]\n build_data['manifest'] = projects\n build_data['invalid_shas'] = dict() # Populated (potentially) later\n\n release_keys = ('product', 'release', 'version', 'build_num')\n release_data = manifest_info.get_release_info()\n product, release, version, build_num = release_data\n build_data.update(dict(zip(release_keys, release_data)))\n\n index_key = f'{product}-{version}'\n build_data['prev_build_num'] = (\n self.prod_ver_index.get(index_key, None)\n )\n\n build_data['commits'] = list() # Populated (potentially) later\n build_data['manifest_sha'] = commit.id.decode()\n build_data['manifest_path'] = manifest_path.decode()\n build_data['timestamp'] = commit.commit_time\n build_data['download_url'] = (\n f'http://latestbuilds.service.couchbase.com/builds/latestbuilds/'\n f'{product}/{release}/{build_num}'\n )\n\n # Used for related (external) data; preserve any existing data\n build_data['metadata'] = build_data.get('metadata', dict())\n\n logging.debug(f\"Final build document: {build_data}\")\n self.db.upsert_documents({build_name: build_data})\n\n self.first_prod_ver_build = (\n True if build_data['prev_build_num'] is None else False\n )\n self.prod_ver_index[index_key] = build_num\n self.db.update_product_version_index(self.prod_ver_index)\n\n return build_data","def build(self) -> None:\n\n print(\"Genereting files..\")\n self.doc = self.doc + r'\\end{document}'\n\n f = open(\"latex\\\\\" + self.report_name + '.tex', 'w')\n f.write(self.doc)\n f.close()\n\n os.chdir('latex')\n\n cmd = ['pdflatex', '-interaction', 'nonstopmode', self.report_name + '.tex']\n #cmd = ['pdflatex', '-interaction', self.report_name + '.tex']\n\n for i in range(2):\n proc = subprocess.Popen(cmd)\n proc.communicate()\n retcode = proc.returncode\n if not retcode == 0:\n os.chdir('..')\n raise ValueError('Error {} executing command: {}'.format(retcode, ' '.join(cmd)))\n\n os.unlink(self.report_name + '.aux')\n os.unlink(self.report_name + '.lof')\n os.unlink(self.report_name + '.log')\n os.unlink(self.report_name + '.lot')\n os.unlink(self.report_name + '.out')\n os.unlink(self.report_name + '.toc')\n\n os.chdir('..')","def build_docs(session):\n envbindir = session.bin\n session.install(\"-e\", \".[all,docs]\")\n with session.chdir(\"docs/\"):\n session.run(\n \"sphinx-autobuild\",\n \"-j\",\n \"auto\",\n \"--open-browser\",\n \"-qT\",\n \".\",\n f\"{envbindir}/../tmp/html\",\n )","def build(self, file_number, data):\n pass","def test_subProjectDocBuilding(self):\n loreInput, loreOutput = self.getArbitraryLoreInputAndOutput(\"0.3.0\")\n manInput = self.getArbitraryManInput()\n manOutput = self.getArbitraryManHTMLOutput(\"0.3.0\", \"../howto/\")\n structure = {\n \"LICENSE\": \"copyright!\",\n \"twisted\": {\"web\": {\"__init__.py\": \"import WEB\",\n \"topfiles\": {\"setup.py\": \"import WEBINST\"}}},\n \"doc\": {\"web\": {\"howto\": {\"index.xhtml\": loreInput},\n \"man\": {\"twistd.1\": manInput}},\n \"core\": {\"howto\": {\"template.tpl\": self.template}}\n }\n }\n\n outStructure = {\n \"LICENSE\": \"copyright!\",\n \"setup.py\": \"import WEBINST\",\n \"twisted\": {\"web\": {\"__init__.py\": \"import WEB\"}},\n \"doc\": {\"howto\": {\"index.html\": loreOutput},\n \"man\": {\"twistd.1\": manInput,\n \"twistd-man.html\": manOutput}}}\n\n self.createStructure(self.rootDir, structure)\n\n outputFile = self.builder.buildSubProject(\"web\", \"0.3.0\")\n\n self.assertExtractedStructure(outputFile, outStructure)","def test_build(self):\n self.createFakeSphinxProject()\n self.builder.build(self.sphinxDir)\n self.verifyBuilt()","def update_docs():\n site_path = os.path.join(PROJECTS_ROOT, CURRENT_SITE)\n docs_path = os.path.join(site_path, 'doc_src')\n with cd(docs_path):\n run('git reset --hard && git pull --all')\n run('workon djangopatterns && cd doc_src && make clean')\n run('workon djangopatterns && cd doc_src && make json')","def create_dbs_for_project(self):\r\n assert self.index\r\n self.client.indices.create(self.index, ignore=400)\r\n bug_mapping = {\r\n \"bug\": {\r\n \"_id\": {\r\n \"path\": \"bugid\"\r\n },\r\n \"_timestamp\": {\r\n \"enabled\": True,\r\n \"path\": \"openedDate\",\r\n \"format\": \"dateOptionalTime\"\r\n },\r\n \"properties\": {\r\n \"openedDate\": {\r\n \"type\": \"date\",\r\n \"format\": \"dateOptionalTime\"\r\n }\r\n }\r\n }\r\n }\r\n self.client.indices.put_mapping(index=self.index,\r\n doc_type=ElasticSearch.BUGS, body=bug_mapping)\r\n generated_mapping = {\r\n \"generated\" : {\r\n \"properties\" : {\r\n \"data.tar.gz\" : {\r\n \"type\" : \"string\",\r\n \"index\" : \"no\",\r\n \"norms\" : {\r\n \"enabled\" : False\r\n }\r\n }\r\n }\r\n }\r\n }\r\n self.client.indices.put_mapping(index=self.index,\r\n doc_type=ElasticSearch.GENERATED, body=generated_mapping)","def makedocs(projectfolder):\n featuremodel_path = path.join(projectfolder, \"productline\", \"model.xml\")\n configs_path = path.join(projectfolder, \"productline\", \"configs\")\n bddfeatures_path = path.join(projectfolder, \"bddfeatures\")\n testreports_path = path.join(projectfolder, \"testreports\")\n\n fmparser = parsers.FeatureModelParser()\n resultsparser = parsers.TestResultsParser()\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\n\n docs_dir = path.join(projectfolder, \"docs/generated\")\n if path.exists(docs_dir):\n shutil.rmtree(docs_dir)\n makedirs(docs_dir)\n\n lektor_templates_path = \"doc_templates\"\n utilities.sed_inplace(\n path.join(lektor_templates_path, \"aplet.lektorproject\"),\n r'<<PROJECT>>',\n CONFIG[\"project_name\"])\n\n products = {}\n product_names = get_product_names_from_configs_path(configs_path)\n for product_name in product_names:\n productconfig_filepath = path.join(projectfolder, \"productline/configs\", product_name + \".config\")\n product_html_report_name = \"report{0}.html\".format(product_name)\n product_html_results_src = path.join(testreports_path, product_html_report_name)\n product_xml_report_name = \"report{0}.xml\".format(product_name)\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\n\n with open(productconfig_filepath, \"r\") as productconfig_file:\n products[product_name] = {}\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\n\n current_product_lektor_dir = path.join(lektor_templates_path, \"content/products\", product_name)\n if not path.exists(current_product_lektor_dir):\n makedirs(current_product_lektor_dir)\n\n product_filepath = path.join(current_product_lektor_dir,\"contents.lr\")\n shutil.copyfile(path.join(lektor_templates_path, \"helpers/product_contents.lr\"), product_filepath)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\n product_features = configparser.parse_config(productconfig_filepath)\n feature_model.trim_based_on_config(product_features)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \"feature_model\")\n\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\n product_test_status = feature_model.root_feature.test_status\n utilities.sed_inplace(product_filepath, \"<<TEST_STATUS>>\", product_test_status.name)\n\n # Copy test run html report to generated docs\n if path.exists(product_html_results_src):\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\n\n click.echo(\"- Generating feature model SVG...\")\n click.echo(featuremodel_path)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \"content/\"), \"feature_model\")\n\n click.echo(\"- Building site\")\n lektor_cmd = [\"lektor\", \"--project\", lektor_templates_path, \"build\", \"-O\", path.abspath(docs_dir)]\n click.echo(\"Running: \" + subprocess.list2cmdline(lektor_cmd))\n subprocess.call(lektor_cmd)\n\n product_map_renderer = mapbuilder.ProductMapRenderer()\n productline_generated_filepath = path.join(docs_dir, \"index.html\")\n html = product_map_renderer.get_productmap_html(feature_model, products)\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)","def build_docs(branch):\n os.chdir(os.path.join(gitdname, 'docs'))\n sphinx_dir = os.path.join(virtual_dir,'bin')\n retcode = subprocess.call(\"make clean\", shell=True)\n if retcode != 0:\n os.chdir(dname)\n msg = \"\"\"Could not clean the html docs for branch %s\"\"\" % branch\n raise Exception(msg)\n #NOTE: The python call in the below makes sure that it uses the Python\n # that is referenced after entering the virtualenv\n sphinx_call = \" \".join(['make','html',\n \"SPHINXBUILD=' python /usr/local/bin/sphinx-build'\"])\n activate = os.path.join(virtual_dir, \"bin\", \"activate\")\n activate_virtualenv = \". \" + activate\n #NOTE: You have to enter virtualenv in the same call. As soon as the\n # child process is done, the env variables from activate are lost.\n # getting the correct env from bin/activate and passing to env is\n # annoying\n retcode = subprocess.call(\" && \".join([activate_virtualenv, sphinx_call]),\n shell=True,\n env = {'MATPLOTLIBRC' : # put this in the environment to use local rc\n '/home/skipper/statsmodels/statsmodels/tools/',\n # Need this for my openblas setup on my laptop\n 'LD_LIBRARY_PATH' : os.getenv('LD_LIBRARY_PATH')})\n\n if retcode != 0:\n os.chdir(dname)\n msg = \"\"\"Could not build the html docs for branch %s\"\"\" % branch\n raise Exception(msg)\n os.chdir(dname)","def generate_patch_build(self, domain):\n # TODO change name of def\n base_path = self.paths[\"api_doc_dir\"]\n self.generate_apidoc_patches()\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\n patch_generator.filter_for_deleted_apis()\n\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\n\n output = process.communicate()[0]\n if output:\n\n with open(self.paths[\"base_dir\"] + \"/apidoc.json\", 'w') as outfile:\n apidoc_content = {\"url\": \"https://ib-backend-dev.apigateway.in\",\n \"version\": \"0.0.1\",\n \"description\": \"\",\n \"name\": \"iBHubs_backend API Documentation\",\n \"title\": \"iBHubs_backend Documenation\"}\n json.dump(apidoc_content, outfile, indent=4)\n # by default we assume user is working at no specific branch so we fix\n # url to default above url as above , then we check if any specific parametr is given\n # and replace url with required url\n if domain != '' and domain:\n with open(self.paths[\"apidoc\"]) as src_json:\n apidoc_content = json.load(src_json)\n apidoc_content['url'] = \"https://\" + domain\n with open(self.paths[\"apidoc\"], 'w') as outfile:\n json.dump(apidoc_content, outfile, indent=4)\n try:\n os.mkdir(\"docs\")\n except OSError:\n pass\n # the below command is responsible for creating docs\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\n '-o', os.path.join(self.base_dir, 'docs'),\n '-e', 'django_swagger_utils/*',\n '-e', 'static/*',\n ], stdout=subprocess.PIPE)\n print process.communicate()[0]\n ################################################\n # hosting apidoc\n ################################################\n # obtaining the path of static folder of django-swagger-utils\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \"../..\"))\n # static_folder_path = os.path.join(django_swagger_utils_path, \"static\")\n # import shutil\n # # create a folder apidoc , delete if previously exists\n # if os.path.exists(os.path.join(static_folder_path, \"apidoc\")):\n # shutil.rmtree(os.path.join(static_folder_path, \"apidoc\"))\n # apidoc_path = os.path.join(static_folder_path, \"apidoc\")\n #\n # os.mkdir(apidoc_path)\n\n # from distutils.dir_util import copy_tree\n # copydocs from docs to apidoc in swagger utils\n # try:\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\n # except Exception as err:\n # print err\n\n # browse to localhost:<port>/static/apidoc/index.html\n\n else:\n raise CommandError(\"Help: Install apidoc: [ sudo npm install -g apidoc ]\")","def _createDataFromProject(self):\n data = []\n project_dict = self._project.asDict()\n for phase_id, phase_dict in project_dict['phases'].items():\n for fitable_id, fitable_dict in phase_dict['cell'].items():\n data.append({\n 'id': ['phases', phase_id, 'cell', fitable_id],\n 'label': '{} {}'.format(phase_id, fitable_id),\n 'value': fitable_dict['value'],\n 'error': fitable_dict['error'],\n 'refine': fitable_dict['refine']\n })\n return data","def get_data(self, **kwargs):\n\n self.data = {}\n #node_data = ''\n #link_data = ''\n templates_data = self.request_from_server('templates')\n self.templates = templates_data\n project_data = self.request_from_server('projects')\n for project in project_data:\n project_name = project['name']\n if 'project_name' in kwargs:\n if project_name != kwargs['project_name']:\n continue\n\n self.data[project_name] = {}\n self.data[project_name]['project_id'] = project['project_id']\n self.data[project_name]['nodes'] = {}\n node_data = self.request_from_server('projects/{}/nodes'.format(project['project_id']))\n link_data = self.request_from_server('projects/{}/links'.format(project['project_id']))\n for node in node_data:\n node_name = node['name']\n self.data[project_name]['nodes'][node_name] = {}\n self.data[project_name]['nodes'][node_name]['node_id'] = node['node_id']\n self.data[project_name]['nodes'][node_name]['template_id'] = node['template_id']\n self.data[project_name]['nodes'][node_name]['node_type'] = node['node_type']\n self.data[project_name]['nodes'][node_name]['console_port'] = node['console']\n self.data[project_name]['nodes'][node_name]['console_session'] = None\n self.data[project_name]['nodes'][node_name]['x'] = node['x']\n self.data[project_name]['nodes'][node_name]['y'] = node['y']\n self.data[project_name]['nodes'][node_name]['ports'] = {}\n if project['status'] != 'closed':\n self.data[project_name]['nodes'][node_name]['status'] = node['status']\n for port in node['ports']:\n port_name = port['short_name']\n self.data[project_name]['nodes'][node_name]['ports'][port_name] = {}\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['adapter_number'] = port['adapter_number']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['port_number'] = port['port_number']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_type'] = port['link_type']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_id'] = None\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['in_use'] = False\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = None\n for link in link_data:\n for link_node in link['nodes']:\n if node['node_id'] == link_node['node_id']:\n if link_node['label']['text'] == port_name:\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_id'] = link['link_id']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['in_use'] = True\n if link['nodes'].index(link_node) == 0:\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to_id'] = link['nodes'][1]['node_id']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = self.get_node_name_from_id(project_name,link['nodes'][1]['node_id'])\n else:\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to_id'] = link['nodes'][0]['node_id']\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = self.get_node_name_from_id(project_name,link['nodes'][0]['node_id'])","def build(_):","def build(\n ctx,\n skip,\n enable_doxygen_conf,\n enable_doxygen,\n enable_symlinks,\n enable_sphinx,\n use_doxygen_conf_in,\n doxygen_conf_defaults_path,\n dox,\n skip_dox,\n warning_is_error,\n nitpicky,\n):\n root_project_dir = discover_conf_py_directory(ctx.obj[\"root_project_dir\"])\n\n if doxygen_conf_defaults_path is not None:\n _doxygen_conf_defaults_path = Path(doxygen_conf_defaults_path)\n else:\n _doxygen_conf_defaults_path = None\n\n return_code = build_stack_docs(\n root_project_dir,\n skipped_names=skip,\n prefer_doxygen_conf_in=use_doxygen_conf_in,\n doxygen_conf_defaults_path=_doxygen_conf_defaults_path,\n enable_doxygen_conf=enable_doxygen_conf,\n enable_doxygen=enable_doxygen,\n enable_package_links=enable_symlinks,\n enable_sphinx=enable_sphinx,\n select_doxygen_packages=dox,\n skip_doxygen_packages=skip_dox,\n warning_is_error=warning_is_error,\n nitpicky=nitpicky,\n )\n if return_code > 0:\n sys.exit(return_code)","def read_doc(self):\n self.data_read[:] = []\n for para in self.document.paragraphs:\n text = para.text\n # skip blank lines\n if text.strip():\n # remove duplicated spaces\n text = ' '.join(text.split())\n # for older versions of final CAPA's\n self.fill_project_info(text, new_format=False)\n self.data_read.append(text)\n\n # Constant in old & new report format\n # Batch/Project name\n # Lead(s)'s name\n # Reported date\n for i in range(0, len(self.data_read)):\n if next((x for x in self.leads if x in self.data_read[i]), None):\n self.project_info.update({'Project Name': self.data_read[i - 1]})\n self.project_info.update({'Lead(s)': self.data_read[i]})\n self.project_info.update({'Date Reported': self.data_read[i + 1]})\n break","def build(working_directory, configuration):\n\n # Copy README.rst to docs/temp/README.html\n # Doxygen may not create the output folder, ensure it exists.\n\n temp_dir = os.path.join(working_directory, \"temp\")\n create_folder_if_needed(temp_dir)\n\n # Needed for dot generated docs\n create_folder_if_needed(os.path.join(temp_dir, \"images\"))\n\n # Process all the .dot files\n for item in os.listdir(working_directory):\n\n # Process the .dot files\n if _DOT_MATCH.match(item):\n # Call dot to create the files\n run_command(\n (\"dot\", \"-Tpng\", item, \"-otemp{0}images{0}{1}.png\".format(\n os.sep, item[:-4])),\n working_dir=working_directory)\n\n\n # Get the input and output file names\n source = os.path.join(os.path.dirname(working_directory), \"README.rst\")\n dest = os.path.join(temp_dir, \"README.html\")\n\n # Was the file already created and newer than the source?\n if is_source_newer(source, dest):\n\n # Load pandoc if needed to do the conversion\n pypandoc.ensure_pandoc_installed(delete_installer=True)\n pypandoc.convert_file(source, to=\"html\", outputfile=dest)\n return 0","def build(self):\n\t\tself.documents = self.get_items_to_index()\n\t\tself.build_index()","def build_pdf(branch):\n os.chdir(os.path.join(gitdname,'statsmodels','docs'))\n sphinx_dir = os.path.join(virtual_dir,'bin')\n retcode = subprocess.call(\" \".join(['make','latexpdf',\n 'SPHINXBUILD='+sphinx_dir+'/sphinx-build']), shell=True)\n if retcode != 0:\n os.chdir(old_cwd)\n msg = \"\"\"Could not build the pdf docs for branch %s\"\"\" % branch\n raise Exception(msg)\n os.chdir(dname)","def set_project_values(project, data):\n project.hashtag = data['hashtag']\n if 'name' in data and len(data['name']) > 0:\n project.name = data['name']\n else:\n project.name = project.hashtag.replace('-', ' ')\n if 'summary' in data and len(data['summary']) > 0:\n project.summary = data['summary']\n has_longtext = 'longtext' in data and len(data['longtext']) > 0\n if has_longtext:\n project.longtext = data['longtext']\n if 'autotext_url' in data and data['autotext_url'].startswith('http'):\n project.autotext_url = data['autotext_url']\n if not project.source_url or project.source_url == '':\n project.source_url = data['autotext_url']\n # MAX progress\n if 'levelup' in data and 0 < project.progress + data['levelup'] * 10 < 50:\n project.progress = project.progress + data['levelup'] * 10\n # return jsonify(data=data)\n if project.autotext_url is not None and not has_longtext:\n # Now try to autosync\n project = AddProjectData(project)\n return project","def build_docs(options):\r\n verbose = getattr(options, 'verbose', False)\r\n\r\n cmd = \"cd {dir}; make html quiet={quiet}\".format(\r\n dir=doc_path(options),\r\n quiet=\"false\" if verbose else \"true\"\r\n )\r\n\r\n sh(cmd)","def build_DB(self, doc_files):\n\t\tcompteur=0\n\t\tdoc_name=doc_files+'doc_'+str(compteur)+'.txt'\n\t\twhile os.path.exists(doc_name):\n\t\t doc=Doc(doc_name)\n\t\t self.DB.add_doc(doc)\n\t\t compteur+=1\n\t\t doc_name=doc_files+'doc_'+str(compteur)+'.txt'\n\t\tprint \"Number of documents in the Data Base: \", self.DB.nb_doc_total\n\t\t#print self.DB.id2nbword\n\t\tself.dump_DB()","def build(self):\n self.puts(colored.blue(\"Building project...\"))\n\n if os.path.exists(self.build_path):\n shutil.rmtree(self.build_path)\n os.makedirs(self.build_path)\n\n with indent(2):\n self._reset_build_sequence_id()\n self._build_pre_project_template()\n self._build_project_template()\n self._build_pre_resources_template()\n self._build_resources_template()\n self._build_post_resources_template()","def do_build():\n tmp_dir = Path(tempfile.mkdtemp())\n (tmp_dir / \"integrations-docs.js\").write_text(render_js_module(collect_docs(), *collect_metrics(), collect_meta()))\n\n symlink_images(tmp_dir)\n\n shutil.rmtree(OUT_DIR, ignore_errors=True)\n tmp_dir.replace(OUT_DIR)","def test_project(self, doi_dataset, doi_bib, orcid, metadata_parser):\n apply_mock(doi_dataset, doi_bib, orcid, metadata_parser)\n os.chdir(\"input/\")\n _set_args(\"-i\",\"yamls/project.yaml\",\"-o\",\"../out\")\n with HiddenPrints():\n ya2ro.main()\n\n data = yaml.load(\"yamls/project.yaml\", Loader=SafeLoader)\n with open(\"../out/project/index-en.html\") as f:\n web = f.read()\n\n self.assert_data_in_web(data, web)","def main(*, build, subdir, description, supports_modules=False,\n supports_quick=False):\n parser = argparse.ArgumentParser(description=description)\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\n \"--serve\", action='store_true',\n help=\"Serve the documentation on the given PORT for easy preview.\")\n group.add_argument(\n \"--out_dir\", type=str, metavar=\"DIR\",\n help=\"Generate the documentation to the given output directory.\"\n \" The DIR must be an absolute path.\"\n \" If DIR already exists, then it must be empty.\"\n \" (For regression testing, the DIR can be the magic value <test>,\"\n \" in which case a $TEST_TMPDIR subdir will be used.)\")\n parser.add_argument(\n \"--port\", type=int, metavar=\"PORT\", default=8000,\n help=\"Use a non-default PORT when serving for preview.\")\n parser.add_argument(\n \"--verbose\", action=\"store_true\",\n help=\"Echo detailed commands, progress, etc. to the console\")\n if supports_modules:\n parser.add_argument(\n \"module\", nargs=\"*\",\n help=\"Limit the generated documentation to only these modules and \"\n \"their children. When none are provided, all will be generated. \"\n \"For example, specify drake.math or drake/math for the C++ \"\n \"module, or pydrake.math or pydrake/math for the Python module.\")\n if supports_quick:\n parser.add_argument(\n \"--quick\", action=\"store_true\", default=False,\n help=\"Omit from the output items that are slow to generate. \"\n \"This yields a faster preview, but the output will be incomplete.\")\n args = parser.parse_args()\n if args.verbose:\n global _verbose\n _verbose = True\n curried_build = build\n if supports_modules:\n canonicalized_modules = [\n x.replace('/', '.')\n for x in args.module\n ]\n curried_build = functools.partial(\n curried_build, modules=canonicalized_modules)\n if supports_quick:\n curried_build = functools.partial(\n curried_build, quick=args.quick)\n if args.out_dir is None:\n assert args.serve\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\n else:\n _do_generate(build=curried_build, out_dir=args.out_dir,\n on_error=parser.error)","def dataComponent_build(self, **kwargs):\n\n str_path = '/'\n str_plugin = 'PACSPull'\n ft_convertFrom = None\n str_convertTo = ''\n SeriesFilesCount = 3\n dataTree = None\n for key,val in kwargs.iteritems():\n if key == 'path': str_path = val\n if key == 'plugin': str_plugin = val\n if key == 'tree_convertFrom': ft_convertFrom = val\n if key == 'type_convertTo': str_convertTo = val\n if key == 'SeriesFilesCount': SeriesFilesCount = val\n\n s = self.contents\n\n if s.cd(str_path)['status']:\n s.mknode(['dataView', 'plugins'])\n if str_plugin.lower() == 'pacspull':\n dataTree = self.dataTree_PACSPull_build(\n SeriesFilesCount = SeriesFilesCount\n )\n # print(dataTree)\n if str_plugin.lower() == 'mri_convert':\n if ft_convertFrom and len(str_convertTo):\n dataTree = self.dataTree_mriConvert_build(\n PACSPullTree = ft_convertFrom,\n convertTo = str_convertTo\n )\n if str_plugin.lower() == 'recon-all':\n dataTree = self.dataTree_reconall()\n if str_plugin.lower() == 'tractography':\n dataTree = self.dataTree_tractography()\n s.cd('dataView')\n s.graft(dataTree, '/files')\n s.cd('/')\n s.tree_metaData_print(False)","def generate_api_docs(self):\n if self.API_OUTPUT_DIR:\n args = [\n # Put documentation for each module on its own page\n '-e',\n # don't create the \"modules.rst\" file (the table of contents\n # file) as this is already provided by the package's main rst\n # file.\n '-T',\n # Overwrite existing files\n '--force',\n '-o', self.API_OUTPUT_DIR,\n # the package to generate docs from\n self.PROJECT_DIR\n ]\n excludes = [\n os.path.join(self.PROJECT_DIR, p)\n if not os.path.isabs(p) else p\n for p in self.API_EXCLUDE_DIRS\n ]\n apidoc.main(args + excludes)","def do_docs(self, path):\n print(\"scaraping documentation\")\n for p in path.glob(\"**/*\"):\n if p.is_file():\n parts = p.relative_to(path).parts\n if parts[-1].endswith(\"rst\"):\n data = tsparse(p.read_bytes())\n blob = DocBlob()\n blob.arbitrary = data\n blob.content = {}\n\n blob.ordered_sections = []\n blob.item_file = None\n blob.item_line = None\n blob.item_type = None\n blob.aliases = []\n blob.example_section_data = Section()\n blob.see_also = []\n blob.signature = None\n blob.references = None\n blob.refs = []\n\n self.docs[parts] = json.dumps(blob.to_json(), indent=2)\n else:\n pass\n # data = p.read_bytes()","def get_data(self):\n\n all_data = OrderedDict()\n projects = [Path(proj) for proj in glob(str(self.data_path.joinpath(\"*\"))) if Path(proj).is_dir()]\n\n for project in projects:\n files = []\n \n # Read all csv files and save them as a list in files\n for ver in glob(str(project.joinpath(\"*.csv\"))):\n files.extend(pd.read_csv(ver, usecols=['time', 'buggy']).values.tolist())\n \n # Create a pandas dataframe from the csv sorted by datetime\n df = pd.DataFrame(files, columns=['Time', 'Bugs']).sort_values(by='Time').reset_index(drop=True)\n \n # Convert time to Pandas DateTime format\n df['Time'] = pd.to_datetime(df['Time']) \n \n # Group bug counts by week starting on monday\n df = df.reset_index().set_index('Time').groupby(\n [pd.Grouper(freq='W-MON')])[\"Bugs\"].sum().astype(int).reset_index()\n \n df = df.set_index('Time')\n # Save the data to dictionary\n all_data.update(OrderedDict({project.name: df}))\n\n return all_data","def submit_data(self):\n\n database = Database()\n project_data = []\n\n project_entries = [\"\",\n \"\",\n \"\",\n self.proj_date.get(),\n self.proj_descrpt.get(),\n self.proj_estdatest.get(),\n self.proj_estdateend.get(),\n self.proj_estbudget.get(),\n self.proj_actdatest.get(),\n self.proj_actdateend.get(),\n self.proj_actcost.get()]\n\n index = 0\n num_filled = 0\n for item in project_entries:\n if item == \"\":\n project_entries[index] = None\n else:\n num_filled += 1\n index += 1\n\n cus_name = self.customer_name.get()\n\n if num_filled == 0 and cus_name == \"\":\n ErrorMessageWindow(\"You have to fill in at least one argument!\")\n else:\n # If a customer name is provided.\n if cus_name != \"\":\n customer_data = database.query_customer(cus_name=cus_name)\n if customer_data:\n project_entries[1] = customer_data[0][0]\n project_data = self.multi_project(database.query_project(\n project_query_options=project_entries))\n else:\n ErrorMessageWindow(\"No customer with this name found.\")\n else:\n project_data = self.multi_project(database.query_project(\n project_query_options=project_entries))\n\n if project_data:\n schedule_data = database.query_project_tasks(\n project_data=project_data)\n customer_data = database.query_customer(project_data[0][1])\n\n region_data = database.query_region(\n region_id=customer_data[0][1])\n\n # Project schedule window definition.\n ps_window = tkinter.Tk()\n ps_window.wm_title(\"Project Schedule Display\")\n tkinter.Label(\n ps_window, text=\"Project Information:\"\n ).grid()\n\n # Display project information.\n tkinter.Label(\n ps_window,\n text=\"Project ID: {}\".format(project_data[0][0]),\n ).grid(\n pady=5, column=0, row=1\n )\n tkinter.Label(\n ps_window,\n text=\"Description: {}\".format(project_data[0][4]),\n ).grid(\n pady=5, column=1, row=1\n )\n tkinter.Label(\n ps_window,\n text=\"Company: {}\".format(customer_data[0][2]),\n ).grid(\n pady=5, column=0, row=2\n )\n tkinter.Label(\n ps_window,\n text=\"Contract Date: {}\".format(project_data[0][3]),\n ).grid(\n pady=5, column=1, row=2\n )\n tkinter.Label(\n ps_window,\n text=\"Region: {}\".format(region_data[0][1]),\n ).grid(\n pady=5, column=2, row=2\n )\n tkinter.Label(\n ps_window,\n text=\"Start Date: {}\".format(project_data[0][5]),\n ).grid(\n pady=5, column=0, row=3\n )\n tkinter.Label(\n ps_window,\n text=\"End Date: {}\".format(project_data[0][6]),\n ).grid(\n pady=5, column=1, row=3\n )\n tkinter.Label(\n ps_window,\n text=\"Budget: ${}\".format(project_data[0][7]),\n ).grid(\n pady=5, column=2, row=3\n )\n\n # Schedule table definition.\n p_s_view = tkinter.ttk.Treeview(ps_window)\n p_s_view.grid(pady=10, column=1, row=5)\n\n p_s_view[\"show\"] = \"headings\"\n p_s_view[\"columns\"] = (\n \"Start Date\", \"End Date\", \"Task Description\",\n \"Skill(s) Required\", \"Quantity Required\"\n )\n\n # Table column headings.\n for heading in p_s_view[\"columns\"]:\n p_s_view.heading(heading, text=heading)\n p_s_view.column(heading, width=250)\n\n # Load data into table.\n for item in schedule_data:\n p_s_view.insert('', 'end', values=item)\n else:\n ErrorMessageWindow(\"No project found with given info.\")","def build(config):","def pre_build_project(project_data):\n ListenerManager.call(_project_pre_build_manager, project_data)","def contents_build_1(self, **kwargs):\n\n SeriesFilesCount = 10\n for key,val in kwargs.iteritems():\n if key == 'SeriesFilesCount': SeriesFilesCount = val\n\n # First, build a PACS_pull tree\n self.dataComponent_build(\n path = '/',\n plugin = 'PACSPull',\n SeriesFilesCount = SeriesFilesCount\n )\n\n self.dataComponent_pluginBuild(\n path = '/plugins'\n )\n\n\n # Now \"run\" an mri_convert to nifi\n # self.dataComponent_pluginRun(\n # inputPath = '/dataView/files',\n # outputPath = '/plugin/run',\n # plugin = 'mri_convert'\n # )","def post_build_project(project_data):\n ListenerManager.call(_project_post_build_manager, project_data)","def _build_datasets(self):\n self._build_datasets_sis3302()\n self._build_datasets_sis3305()","def build(opt):\n version = '1.1'\n dpath = os.path.join(opt['datapath'], 'ner')\n\n # check if data had been previously built\n raw_path = os.path.abspath(opt['raw_dataset_path'] or \".\")\n if len([f for f in os.listdir(raw_path) if f.endswith(\".iob\")]) == 0:\n if not build_data.built(dpath, version_string=version):\n print('[target data path: ' + dpath + ']')\n # make a clean directory if needed\n if build_data.built(dpath):\n # an older version exists, so remove these outdated files.\n build_data.remove_dir(dpath)\n build_data.make_dir(dpath)\n\n ds_path = os.environ.get('DATASETS_URL')\n file_name = 'gareev.tar.gz'\n if not ds_path:\n raise RuntimeError(\"Looks like the `DATASETS_URL` variable is set incorrectly\")\n print('Trying to download a dataset %s from the repository' % file_name)\n url = urllib.parse.urljoin(ds_path, file_name)\n build_data.download(url, dpath, file_name)\n build_data.untar(dpath, file_name)\n print('Downloaded a %s dataset' % file_name)\n # mark the data as built\n build_data.mark_done(dpath, version_string=version)\n opt['raw_dataset_path']=dpath\n create_heap_file(opt['raw_dataset_path'])\n else:\n print('Use raw data for {}'.format(opt['raw_dataset_path']))\n create_heap_file(dpath, opt['raw_dataset_path'])\n build_data.mark_done(dpath, version_string=version)\n print(\"Use dataset from path: %s\" % repr(opt['raw_dataset_path']))","def open_doc(self, widget, data=None):\n\t\twebbrowser.open('file://'+os.path.abspath(\"./doc/build/html/index.html\"))","def gen_project(project_name, project_revision, target, template, working_dir):\n gen_project_tcl(project_name, project_revision,\n target, template, working_dir)\n qsys_files = filter(lambda file: file.endswith(\".qsys\"), target.files_list)\n for file in qsys_files:\n gen_qsys_system_from_qsys_file(file, working_dir)\n\n log_msg = \"Generating project\"\n cmd = f\"cd {working_dir} && {QUARTUS_BIN_DIR}quartus_sh -t make_project.tcl\"\n log_file_path = working_dir + \"project_gen.log\"\n\n run_cmd_and_log(cmd, log_msg, log_file_path)","def docs():","def create_project_info(data):\n\t\n\tproject = ProjectInfo()\n\tproject.name = data['name']\n\tproject.description = data['description']\n\tproject.start_date = data['start_date']\n\tproject.end_date = data['end_date']\n\tproject.save()\n\tprint ('Inserted')\n\treturn True","def build(root):","def get_projects_data():\n wcscanner_path = context.__BASE_PATH__ + '/.wcscanner'\n\n data = []\n for project in os.listdir(wcscanner_path):\n if (os.path.isdir(os.path.join(wcscanner_path, project))):\n update_project_data(project)\n project_path = '{}/{}'.format(wcscanner_path, project)\n f = open('{}/.project'.format(project_path), 'r')\n data.append(json.load(f))\n f.close()\n return data","def write_data_index(self):\n content = \"\"\n self.remove(os.path.join(config[\"data_subdir\"], \"*\"))\n if self.data_index:\n print(\"- writing data index\")\n content += f\"# [{config['github_repo_name']}]({config['github_pages_url']})\\n\"\n content += \"\\n## Index of Data files in this Repository\\n\"\n for data, links in sorted(self.data_index.items(), key=lambda x: natsort(x[0])):\n if links:\n content += f\"\\n### {data}\\n\"\n content += f\"\\n\"\n for link in links:\n content += f\"* {link}\\n\"\n data_src = os.path.join(self.src_dir, config[\"data_subdir\"], data)\n data_dst = os.path.join(self.dst_dir, config[\"data_subdir\"], data)\n print(f\"- copying {data_src} to {data_dst}\")\n shutil.copy(data_src, data_dst)\n self.write_md2html(\"data_index\", content)","def buildPage(self):\n Users = [(u['name']) for u in driver.nodes.match(\"User\")]\n Tissues = [(t['name']) for t in driver.nodes.match(\"Tissue\")]\n Diseases = [(d['name']) for d in driver.nodes.match(\"Disease\")]\n self.add_basic_layout()\n layout = [html.Div([\n html.Div([html.H4('Project information', style={'width': '15.5%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.H4('', id='update_project_id', style={'width': '15%', 'verticalAlign': 'top', 'display': 'none'}),\n html.Br(),\n html.Div(children=[html.Label('Project name:*', style={'marginTop': 15}),\n dcc.Input(id='project name', placeholder='Insert name...', type='text', style={'width': '100%', 'height': '35px'})],\n style={'width': '100%'}),\n html.Br(),\n html.Div(children=[html.Label('Project Acronym:', style={'marginTop': 15}),\n dcc.Input(id='project acronym', placeholder='Insert name...', type='text', style={'width': '100%', 'height': '35px'})],\n style={'width': '100%'}),\n html.Br(),\n html.Div(children=[html.Label('Project Responsible:*', style={'marginTop': 15})],\n style={'width': '49%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[html.Label('Project Participants:*', style={'marginTop': 15})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Dropdown(id='responsible-picker', options=[{'label': i, 'value': i} for i in Users], value=[], multi=True, searchable=True, style={'width': '100%'})],\n style={'width': '49%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Dropdown(id='participant-picker', options=[{'label': i, 'value': i} for i in Users], value=[], multi=True, searchable=True, style={'width': '100%'})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Br(),\n html.Br(),\n html.Div(children=[html.Label('Project Data Types:*', style={'marginTop': 10})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[html.Label('Project Disease:*', style={'marginTop': 10})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Dropdown(id='data-types-picker', options=[{'label': i, 'value': i} for i in DataTypes], value=[], multi=True, searchable=True, style={'width': '100%'})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Dropdown(id='disease-picker', options=[{'label': i, 'value': i} for i in Diseases], value=[], multi=True, searchable=True, style={'width': '100%'})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Br(),\n html.Br(),\n html.Div(children=[html.Label('Project Tissue:*', style={'marginTop': 10})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[html.Label('Project Intervention:', style={'marginTop': 10})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Dropdown(id='tissue-picker', options=[{'label': i, 'value': i} for i in Tissues], value=[], multi=True, searchable=True, style={'width': '100%'})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Input(id='intervention-picker', placeholder='E.g. SNOMED identifier|SNOMED identifier|...', type='text', style={'width': '100%', 'height': '54px'})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Br(),\n html.Br(),\n html.Div(children=[html.Label('Number of subjects:*', style={'marginTop': 15})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[html.Label('Timepoints:', style={'marginTop': 15})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Input(id='number_subjects', placeholder='E.g. 77 (each unique patient counts as 1 subject)', type='text', style={'width': '100%', 'height': '35px'})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Div(children=[dcc.Input(id='number_timepoints', placeholder='E.g. 2 months|15 days|24 hours...', type='text', style={'width': '100%', 'height': '35px'})],\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Br(),\n html.Br(),\n html.Div(children=[html.Label('Follows up project:', style={'marginTop': 15}),\n dcc.Input(id='related_to', placeholder='Use the Project Identifier (P000000X)', type='text', style={'width': '100%', 'height': '35px'})],\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\n html.Br(),\n html.Br(),\n html.Div(children=[html.Label('Project Description:', style={'marginTop': 15}),\n dcc.Textarea(id='project description', placeholder='Enter description...', style={'width': '100%', 'height': '100px'})]),\n html.Br(),\n html.Div(children=[html.Label('Starting Date:', style={'marginTop': 10}),\n dcc.DatePickerSingle(id='date-picker-start', placeholder='Select date...', clearable=True)],\n style={'width': '30%', 'verticalAlign': 'top', 'marginTop': 10, 'display': 'inline-block'}),\n html.Div(children=[html.Label('Ending Date:', style={'marginTop': 10}),\n dcc.DatePickerSingle(id='date-picker-end', placeholder='Select date...', clearable=True)],\n style={'width': '30%', 'verticalAlign': 'top', 'marginTop': 10, 'display': 'inline-block'}),\n html.Div(children=html.Button('Create Project', id='project_button', n_clicks=0, className=\"button_link\",\n style={'fontSize': '25px'}), style={'width': '100%', 'padding-left': '87%', 'padding-right': '0%'}),\n html.Br(),\n html.Div(children=[html.A(children=html.Button('Download Clinical Data template', id='download_button', n_clicks=0,\n style={'fontSize': '16px', 'display': 'block'}),\n id='download_link', href='', n_clicks=0)], style={'width': '100%', 'padding-left': '87%', 'padding-right': '0%'}),\n html.Br(),\n html.Div(id='project-creation', style={'fontSize': '20px', 'marginLeft': '70%'}),\n html.Br()]),\n html.Hr()])]\n\n self.extend_layout(layout)","def _make_data(self):\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)","def index():\n with open(\"PROJECT.md\", \"r\") as project_file:\n md_template_string = markdown.markdown(\n project_file.read(), extensions=[\"fenced_code\"]\n )\n return md_template_string","def build(self, data: dict) -> GenerativeDesignExecution:\n execution = GenerativeDesignExecution.build(data)\n execution._session = self.session\n execution.project_id = self.project_id\n return execution","def buildHTML(self):\n\n # TODO: make this configurable via a dialog\n os.chdir(self.file_path.parent)\n proc = subprocess.Popen(\n [\"make\", \"clean\"],\n stdin=subprocess.PIPE,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT\n )\n for line in proc.stdout:\n print(\"stdout: \" + str(line.rstrip(), encoding='utf8'))\n print('----------------')\n proc = subprocess.Popen(\n [\"make\", \"html\"],\n stdin=subprocess.PIPE,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT\n )\n proc.wait()\n for line in proc.stdout:\n print(\"stdout: \" + str(line.rstrip(), encoding='utf8'))\n\n # Load corresponding HTML file from newly-built Sphinx docs\n self.preview.load_html(self.output_html_path)","def qck_gen_proj(self, master):\r\n if not self._check_project_name():\r\n return\r\n\r\n # Clear out driver list and board\r\n self.newProj.board = ()\r\n self.newProj.drvList = []\r\n\r\n # Configure ksdkProj given GUI state\r\n self.localSDK.get_version()\r\n self.newProj.name = self.widgetList[4].get()\r\n self.newProj.setKsdkPath(self.localSDK.path)\r\n self.newProj.sdkVer = self.localSDK.version\r\n self.newProj.useBSP = not self.localSDK.isNewVersion()\r\n\r\n # Add the board\r\n try:\r\n userBoard = int(self.widgetList[6].curselection()[0]) + 1\r\n self.newProj.add_board(userBoard, self.localSDK.brdList)\r\n except IndexError:\r\n tkMessageBox.showinfo(\"No board selected!\",\\\r\n \"Make sure a board has been selected.\")\r\n return\r\n\r\n self.widgetList[10].step(30)\r\n self.widgetList[10].update_idletasks()\r\n\r\n # Quick check to see if this poject already exists\r\n checkPath = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/' + self.newProj.name\r\n if os.path.isdir(checkPath):\r\n tkMessageBox.showinfo(\"Project exists\",\\\r\n \"A project by this name already exists.\")\r\n return\r\n\r\n # in quick mode there is always generated the board project\r\n self.newProj.isBoardProject = True\r\n \r\n # Add all drivers for this device\r\n self.localSDK.get_drivers()\r\n maskRet = kT.mask_features(kTool.KsdkTools(), self.newProj.sdkPath, self.newProj.sdkVer, \\\r\n self.localSDK.drvList, self.newProj.device[1], self.newProj.device[2])\r\n self.newProj.portCount = maskRet[0]\r\n self.newProj.dmaCount = maskRet[1]\r\n self.newProj.tsiVersion = maskRet[2]\r\n self.newProj.add_all_drv(self.localSDK.drvList)\r\n\r\n kT.debug_log('Port Count: ' + str(self.newProj.portCount))\r\n\r\n #Generate IAR project files\r\n #self.newProj.fast_build_IAR()\r\n self.newProj.workSpace = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/'\r\n projectPath = self.newProj.workSpace + self.newProj.name\r\n\r\n #Get all include paths lists into one list\r\n includeList = []\r\n index = 0\r\n isPresent = False\r\n while index < len(self.newProj.drvList):\r\n count = 0\r\n while count < len(self.newProj.drvList[index][2]):\r\n isPresent = False\r\n newPath = str(\\\r\n self.newProj.drvList[index][2][count]\\\r\n )\r\n if len(includeList) > 0:\r\n listIndex = 0\r\n while listIndex < len(includeList):\r\n if newPath == includeList[int(listIndex) - 1]:\r\n isPresent = True\r\n listIndex += 1\r\n if not isPresent:\r\n includeList.append(newPath)\r\n count += 1\r\n index += 1\r\n\r\n self.newProj.libList.append('platform')\r\n if not os.path.isdir(projectPath):\r\n os.makedirs(projectPath)\r\n self.newProj.rtos = 'bm'\r\n\r\n if not os.path.isfile(projectPath + '/main.c'):\r\n self.newProj.make_main_file(projectPath, includeList)\r\n if not os.path.isfile(projectPath + '/hardware_init.c'):\r\n self.newProj.make_hw_file(projectPath)\r\n\r\n self.widgetList[10].step(30)\r\n self.widgetList[10].update_idletasks()\r\n\r\n ## Copy over BSP files\r\n if self.newProj.useBSP:\r\n if not os.path.isdir(projectPath + '/board'):\r\n os.mkdir(projectPath + '/board')\r\n bspDir = self.newProj.sdkPath + '/examples/' + self.newProj.board[1]\r\n bspList = kT.list_files(bspDir)\r\n for f in bspList:\r\n if f[-2:] == '.c':\r\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\r\n if f[-2:] == '.h':\r\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.IARname, self.newProj.device):\r\n print self.newProj.isLinked\r\n if self.localSDK.isNewVersion():\r\n newIar = kIarNew.KsdkIarNew(self.newProj)\r\n else:\r\n newIar = kIar.KsdkIar(self.newProj)\r\n newIar.gen_ewp(self.newProj)\r\n newIar.gen_eww(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KeilMDK, self.newProj.device):\r\n #Generate MDK project files\r\n if self.localSDK.isNewVersion():\r\n newMdk = kMdkNew.KsdkMdkNew(self.newProj)\r\n else:\r\n newMdk = kMdk.KsdkMdk(self.newProj)\r\n newMdk.gen_proj(self.newProj)\r\n newMdk.gen_wkspace(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KinetisDesignStudio, self.newProj.device):\r\n #Generate KDS project fiels\r\n print self.newProj.isLinked\r\n if self.localSDK.isNewVersion():\r\n newKds = kKdsNew.KsdkKdsNew(self.newProj)\r\n else:\r\n newKds = kKds.KsdkKds(self.newProj)\r\n\r\n newKds.gen_cproject(self.newProj)\r\n newKds.gen_project(self.newProj)\r\n newKds.gen_working_set(self.newProj)\r\n newKds.gen_debug(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.AtollicStudio, self.newProj.device):\r\n #Generate ATL project files\r\n if self.localSDK.isNewVersion():\r\n newAtl = kAtlNew.KsdkAtlNew(self.newProj)\r\n else:\r\n newAtl = kAtl.KsdkAtl(self.newProj)\r\n newAtl.gen_cproject(self.newProj)\r\n newAtl.gen_project(self.newProj)\r\n newAtl.gen_debug(self.newProj)\r\n newAtl.gen_settings(self.newProj)\r\n\r\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.ARMgcc):\r\n #Generate GCC project files\r\n if not self.newProj.fast_build_GCC():\r\n tkMessageBox.showinfo(\"Missing CMake Files\",\\\r\n \"CMake files are missing from your KSDK installation.\")\r\n\r\n #Text for window\r\n genString = 'Your project was created in the following location:\\n'\r\n pathString = ''\r\n pathString += self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath( self.newProj.board[1]) + '/' + self.newProj.name + '/'\r\n genString += pathString\r\n genString += '\\nPress the button below to open project location folder.'\r\n\r\n #Create window to show USER that project has been generated and where it is.\r\n popGen = Toplevel()\r\n if self.newProj.osType == 'Windows':\r\n winH = 100 * WIN_SCALE\r\n winW = 600 * WIN_SCALE\r\n elif self.newProj.osType == 'Darwin':\r\n if platform.mac_ver()[0][:5] == '10.10':\r\n winH = 100\r\n winW = 600\r\n elif platform.mac_ver()[0][:5] == '10.11':\r\n winH = 100\r\n winW = 660\r\n else:\r\n winH = 100\r\n winW = 600\r\n popGen.config(height=winH, width=winW)\r\n popGen.grid()\r\n if self.newProj.osType == 'Linux':\r\n img = Image(\"photo\", data=kImg.boardImages['kds_icon.gif']) # Use the .gif in Linux\r\n popGen.tk.call('wm', 'iconphoto', popGen._w, img)\r\n popGen.title(\"Project created\")\r\n popGen.geometry('%dx%d+%d+%d' % (winW, winH, master.winfo_x() + 20, master.winfo_y() + 20))\r\n popGen.resizable(width=FALSE, height=FALSE)\r\n popGen.configure(background='#E7E7E7')\r\n\r\n genTxt = Label(popGen, text=genString, justify=LEFT)\r\n genTxt.grid(row=0, column=0, columnspan=2, padx=5, pady=5)\r\n\r\n #Create button to open project folder\r\n ## IF we are in windows, we need to replace all '/' with '\\\\'\r\n tempString = pathString[:]\r\n if self.newProj.osType == 'Windows':\r\n pathString = ''\r\n pathString = kT.string_replace(tempString, '/', '\\\\')\r\n\r\n genButton = Button(popGen, text='Open Project Folder', command=lambda: self.view_project(pathString, popGen))\r\n genButton.grid(row=2, column=0, sticky=W, padx=5, pady=5)\r\n\r\n self.widgetList[10].step(35)\r\n self.widgetList[10].update_idletasks()\r\n\r\n # patch to implement automation test\r\n self.pop_gen = popGen\r\n\r\n return","def generate_page_sections_dict(self, project_page_data: dict):\n wiki_obj = WikiService()\n\n short_description = (\n f\"\\n{project_page_data['project']['shortDescription']}\\n\"\n )\n\n created_date = wiki_obj.format_date_text(\n project_page_data['project']['created']\n )\n # created_date_text = f\"\\n{created_date}\\n\" \n # due_date = wiki_obj.format_date_text(\n # project_page_data['project']['due_date']\n # )\n timeframe = (\n f\"\\n* '''Start Date:''' {created_date}\\n\"\n # f\"\\n* '''End Date:''' Estimate {due_date}\\n\"\n )\n\n\n project_url = (\n f\"\\n{project_page_data['project']['url']}\\n\"\n )\n\n hashtag = (\n project_page_data['project']['changesetComment']\n )\n hashtag = (\n project_page_data['project']['changesetComment'].replace(\n \"#\", \"<nowiki>#</nowiki>\"\n )\n )\n hashtag_text = (\n f\"\\n{hashtag}\\n\"\n )\n\n instructions_text = (\n project_page_data['project']\n ['externalSource']\n ['instructions']\n )\n instructions = (\n f\"\\n{instructions_text}\\n\"\n )\n\n per_task_instructions_text = (\n project_page_data['project']\n ['externalSource']\n ['perTaskInstructions']\n )\n per_task_instructions = (\n f\"\\n{per_task_instructions_text}\\n\"\n )\n\n imagery_text = (\n project_page_data['project']\n ['externalSource']\n ['imagery']\n )\n imagery = (\n f\"\\n{imagery_text}\\n\"\n )\n\n license_text = (\n project_page_data['project']\n ['externalSource']\n ['license']\n )\n license = (\n f\"\\n{license_text}\\n\"\n )\n\n # metrics = (\n # f\"\\n* {project_page_data.instructions}\\n\"\n # )\n # quality_assurance = (\n # f\"\\n* {project_page_data.quality_assurance}\\n\"\n # )\n\n users = project_page_data['project'][\"users\"]\n project_users = \"\"\n for user in users:\n project_users += (\n f\"\\n| {user['userId']}\\n| {user['userName']}\\n|-\"\n )\n\n \n\n project_page_sections = {\n self.short_description_section: short_description,\n self.timeframe_section: timeframe,\n # self.timeframe_section: {\n # self.created_section: created_date_text\n # }, # if choose use subsection for timeframe \n self.url_section: project_url,\n self.external_sources_section: {\n self.instructions_section: instructions,\n self.per_task_instructions_section: per_task_instructions,\n self.imagery_section: imagery,\n self.license_section: license\n },\n self.hashtag_section: hashtag_text,\n # self.instructions_section: instructions,\n # self.metrics_section: metrics,\n # self.quality_assurance_section: quality_assurance,\n self.team_user_section: {\n self.users_list_section: project_users\n }\n }\n return project_page_sections","def update_build_commit_documents(self, build_data):\n\n product, version, prev_build_num = (\n build_data[key] for key\n in ['product', 'version', 'prev_build_num']\n )\n prev_build_data = self.db.get_document(\n f'{product}-{version}-{prev_build_num}'\n )\n\n for project, shas in build_data['manifest'].items():\n new_shas = [sha.replace(f'{project}-', '').encode('utf-8')\n for sha in shas]\n old_shas = [sha.replace(f'{project}-', '').encode('utf-8')\n for sha in prev_build_data['manifest'].get(\n project, []\n )]\n\n diff_walker = cbutil_git.DiffWalker(self.repo_base_path / project)\n diff_commits = diff_walker.walk(old_shas, new_shas)\n\n if not diff_commits:\n continue\n\n if old_shas:\n commit_ids = [f'{project}-{commit.id.decode()}'\n for commit in diff_commits]\n else:\n # Only keep most recent commit for new projects\n commit_ids = [f'{project}-{diff_commits[0].id.decode()}']\n\n build_name = build_data['key_']\n logging.debug(f'Updating {build_name} build document for '\n f'the following commits: {\", \".join(commit_ids)}')\n build_document = self.db.get_document(build_name)\n build_document['commits'].extend(commit_ids)\n self.db.upsert_documents({build_name: build_document})\n\n for commit_id in commit_ids:\n commit_document = self.db.get_document(commit_id)\n\n # The check protects from duplicate build document IDs\n # for a commit (potentially due to a loading failure)\n if build_name not in commit_document['in_build']:\n commit_document['in_build'].append(build_name)\n\n self.db.upsert_documents({commit_id: commit_document})","def load_project_udfs(ref_db):\n udfs = prepare_udf_source_info('Project', lims.get_projects())\n project = ref_db.get('project')\n project_details = ref_db.get('project-details')\n for udf, udf_field in udfs.items():\n if 'discontinued' not in udf.split('_'):\n if udf in PROJ_UDF_EXCEPTIONS:\n key = 'project-'+udf\n project[udf] = key\n inf=save_couchdb_ref_obj(ref_db, project)\n else:\n key = 'project-details-'+udf\n project_details[udf] = key\n inf=save_couchdb_ref_obj(ref_db, project_details)\n udf_field['_id'] = key\n inf=save_couchdb_ref_obj(ref_db, udf_field)","def test_main(self):\n self.createFakeSphinxProject()\n self.builder.main([self.sphinxDir.parent().path])\n self.verifyBuilt()","def update_project_data(project_name):\n project_path = context.__PROJECTS_PATH__+ '/' + project_name\n f = open(project_path+'/.project', 'r')\n project_data = json.load(f)\n f.close()\n\n image_count = len(os.listdir(project_path)) - 2\n\n if image_count > 0:\n\n img = Image.open('{}/{}.jpg'.format(project_path, image_count-1))\n img = img.resize((640,480))\n buffered = BytesIO()\n img.save(buffered, format=\"JPEG\")\n img_str = base64.b64encode(buffered.getvalue()).decode('ascii')\n\n project_data['preview_data'] = img_str\n project_data['size'] = round(int(subprocess.check_output(['du', project_path, '-k']).split()[0]) / 1000,2)\n\n with open('{}/.project'.format(project_path), 'w') as config_file:\n json.dump(project_data, config_file, indent=4)\n config_file.close()","def generate():\n local('cd doc && make clean && make html')","def docs(session):\n session.install('-rrequirements-dev.txt')\n session.install('-e', '.')\n run_sphinx(session)","def build_data(path):\n slab_logger.log(15, 'Building ccs-dev-1 site in ccs-data')\n if not os.path.isdir(os.path.join(path, 'services', 'ccs-data')):\n return(1, 'Could not find ccs-data repo. Pleas try \"stack workon ccs-data\"')\n if yaml_utils.decrypt_set(path) != 0:\n return(1, \"unable to decrypt the pulp password\")\n\n data_reponame = \"ccs-data\"\n slab_logger.debug(\"Building the data.\")\n returncode, myinfo = run_this(\n './lightfuse.rb -c hiera-bom-unenc.yaml --site ccs-dev-1 && cd ..',\n cwd=os.path.join(path, \"services\", data_reponame))\n if returncode == 0:\n try:\n # src, dest\n shutil.copyfile(os.path.join(path,\n 'services',\n data_reponame,\n 'out',\n 'ccs-dev-1',\n 'dev-tenant',\n 'etc',\n 'ccs',\n 'data',\n 'hosts'),\n os.path.join(path,\n 'hosts'))\n except IOError as err:\n return(1, err)\n return(returncode, myinfo)","def build(self, data: dict) -> GemTable:\n table = GemTable.build(data)\n table.project_id = self.project_id\n table.session = self.session\n return table","def docs(command, warn_is_error=False, options=\"\"):\n print(\n \"\"\"\nRunning Sphinx to test the docs building\n========================================\n\"\"\"\n )\n o = \"-W \" if warn_is_error else \"\"\n if \"-W\" in options:\n options = options.replace(\"-W\", \"\")\n options = options + \" \" + o\n shutil.rmtree(\"docs/_build\", ignore_errors=True)\n shutil.rmtree(\"docs/api\", ignore_errors=True)\n shutil.rmtree(\"docs/code_reference/api\", ignore_errors=True)\n shutil.rmtree(\"docs/jupyter_execute\", ignore_errors=True)\n shutil.rmtree(\"docs/examples/default_config.yaml\", ignore_errors=True)\n command.run(\"python -m boa.config --output-path docs/examples/default_config.yaml\", echo=True, pty=POSIX)\n command.run(f\"sphinx-build {options} -b html docs docs/_build\", echo=True, pty=POSIX)","def build_data(self):\n from desiutil.io import combine_dicts\n # Loop on exposures\n odict = {}\n for qanight in self.qa_nights:\n for qaexp in qanight.qa_exps:\n # Get the exposure dict\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\n odict = combine_dicts(odict, idict)\n # Finish\n self.data = odict","def build(self, datas):\n\t\t# Browse the list of files\n\t\tfor data in datas:\n\t\t\tif isString(data):\n\t\t\t\tdata = Data(data)\n\t\t\telif isList(data):\n\t\t\t\tstate = None\n\t\t\t\tname = \"\"\n\t\t\t\tif len(data) >= 1:\n\t\t\t\t\tname = data[0]\n\t\t\t\tif len(data) >= 2:\n\t\t\t\t\tstate = data[1]\n\t\t\t\tdata = Data(name, state)\n\t\t\t# Cut the path of the file folder and piece\n\t\t\tself.addNode(self.tree,data.path(),data)","def beehive_make_doc(self):\n run_data = {\n u'tags':[u'doc'],\n u'local_package_path':self.local_package_path\n } \n self.ansible_playbook(u'docs', run_data, \n playbook=self.beehive_doc_playbook)","def Write(self):\n template_mappings = {\n 'pypi_token': self._project_definition.pypi_token or ''}\n\n file_content = []\n\n template_data = self._GenerateFromTemplate('environment', template_mappings)\n file_content.append(template_data)\n\n if self._project_definition.name not in self._PROJECTS_WITHOUT_BUILD:\n if self._project_definition.pypi_token:\n template_data = self._GenerateFromTemplate(\n 'pypi_token', template_mappings)\n file_content.append(template_data)\n\n template_data = self._GenerateFromTemplate('matrix', template_mappings)\n file_content.append(template_data)\n\n template_data = self._GenerateFromTemplate('install', template_mappings)\n file_content.append(template_data)\n\n if self._project_definition.name != 'l2tdevtools':\n template_data = self._GenerateFromTemplate(\n 'install_l2tdevtools', template_mappings)\n file_content.append(template_data)\n\n if self._project_definition.name in self._PROJECTS_WITHOUT_BUILD:\n template_filename = 'build_off'\n else:\n template_filename = 'build'\n\n template_data = self._GenerateFromTemplate(\n template_filename, template_mappings)\n file_content.append(template_data)\n\n template_data = self._GenerateFromTemplate('test_script', template_mappings)\n file_content.append(template_data)\n\n if self._project_definition.name not in self._PROJECTS_WITHOUT_BUILD:\n template_data = self._GenerateFromTemplate('artifacts', template_mappings)\n file_content.append(template_data)\n\n if self._project_definition.pypi_token:\n template_data = self._GenerateFromTemplate(\n 'deploy_script', template_mappings)\n file_content.append(template_data)\n\n file_content = ''.join(file_content)\n\n with io.open(self.PATH, 'w', encoding='utf-8') as file_object:\n file_object.write(file_content)","def _builder_inited(app: sphinx.application.Sphinx) -> None:\n _write_member_documentation_pages(\n _create_documenter(env=app.env,\n documenter_cls=sphinx.ext.autodoc.ModuleDocumenter,\n name='tensorstore'))","def collect_docs() -> Dict[str, Any]:\n docs = {}\n\n for integration_dir, meta in all_integrations():\n integration_name = integration_dir.name\n markdown = \"\"\n for readme in sorted(integration_dir.glob(\"*.md\")) + sorted(integration_dir.glob(\"README.md.jinja\")):\n markdown += readme.read_text(encoding=\"utf-8\")\n\n if not markdown:\n continue\n\n docs[integration_name] = {\n \"markdown\": process_markdown_for_app(markdown, integration_dir, uses_legacy_build(meta))\n }\n\n return docs","def build(self, data: dict):","def _createDataFromProject(self):\n project_dict = self._project.asDict()\n data_blocks = {}\n headers_blocks = {}\n for experiment_id, experiment_dict in project_dict['experiments'].items():\n data = []\n headers = []\n for data_id, data_list in experiment_dict['calculated'].items():\n headers.append(data_id)\n data.append(data_list)\n headers_blocks[experiment_id] = headers\n data_transposed = [*zip(*data)]\n data_blocks[experiment_id] = data_transposed\n return headers_blocks, data_blocks","def build_pages(ctx, show=False):\n\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\n import pages\n import webbrowser\n\n # Update all readmes first\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\n for line in lines:\n print(subprocess.getoutput(['invoke', line]))\n\n pages.build(True, False)\n if show:\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))","def docs(self):\n self._doc_info = DocumentationURL()\n self._doc_info.show()","def __init__(self, project):\n super(ReadTheDocsHelper, self).__init__()\n self._project = project\n self._url_lib_helper = url_lib.URLLibHelper()","def task_mkdocs():\n return Task(\n file_dep=[MKDOCS],\n actions=[\n (needs, [\"jupyter_book\"]),\n ],\n uptodate=[not MKDOCS.exists()],\n )","def with_docs(self):\r\n self._configurations.append('javadoc')\r\n return self","def build_project_dir(self, instance, private_data_dir):\n project_dir = os.path.join(private_data_dir, 'project')\n if not os.path.exists(project_dir):\n os.mkdir(project_dir)","def create_pdf(self):\n\n my_datetime = datetime.now()\n self.pdf_name = (\n self.pdf_name + \"_\" + my_datetime.strftime(\"%H%M_%d%m%Y\") + \".pdf\"\n )\n fig_width = aW * self.column_ratio[0]\n\n clm_width_meta = (aW * self.column_ratio[1]) / len(self.fields)\n\n c = canvas.Canvas(os.path.join(self.pdf_folder, self.pdf_name), pagesize=A4)\n\n for qc_run_id, fig_file in sorted(self._files.items()):\n (param_values, feature_values) = get_param_values(\n qc_run_id, self.db_name, return_meta_add_on=True\n )\n\n comment = self.subject + \"<br/>\"\n # c.saveState()\n title = \"Dataset \" + qc_run_id\n\n # Prepare header\n header = Paragraph(title, title_style)\n h_w, h_h = header.wrap(aW, aH)\n\n # Prepare image\n img = ImageReader(fig_file)\n im_width, im_height = img.getSize()\n aspect = im_height / float(im_width)\n fig_height = fig_width * aspect\n\n # Prepare metadata section\n\n meta_table = Table(\n param_values,\n colWidths=[clm_width_meta] * len(self.fields),\n hAlign=\"CENTER\",\n rowHeights=0.22 * inch,\n )\n meta_table.setStyle(\n TableStyle(\n [\n (\"FONT\", (0, 0), (-1, 0), \"Helvetica-Bold\"),\n (\"FONT\", (0, 1), (-1, -1), \"Helvetica\"),\n (\"LINEBELOW\", (0, 0), (1, 0), 0.08, colors.black),\n (\"SIZE\", (0, 0), (-1, -1), 8),\n (\"VALIGN\", (0, 0), (-1, -1), \"BOTTOM\"),\n # ('ALIGN', (0, 0), (-1, 0), 'CENTER'),\n (\"ALIGN\", (0, 0), (0, -1), \"LEFT\"),\n (\"ALIGN\", (1, 1), (1, -1), \"LEFT\"),\n (\"INNERGRID\", (0, 0), (-1, -1), 0.08, colors.beige),\n # ('BOX', (0,0), (-1,-1), 0.25, colors.grey),\n ]\n )\n )\n\n meta_width, meta_height = meta_table.wrap(aW - im_width, aH / 2)\n\n # Prepare comments header\n comments_header = Paragraph(\"Comments:\", title_style)\n avail_height = aH - fig_height - v_padding\n comm_h_width, comm_h_height = comments_header.wrap(\n im_width, avail_height # aW - meta_width,\n )\n # Prepare comments\n my_datetime = datetime.now()\n ts = \"Printed on \" + my_datetime.strftime(\"%c\")\n\n try:\n data_specific_comment = self.comments[int(qc_run_id)]\n comment += data_specific_comment + \"<br/>\"\n comment += self.comments[\"general\"] + \"<br/>\"\n\n comment += self.smalltalk + \"<br/>\"\n except Exception:\n logger.warning(\n \"Unable to summarize result of \" + \"dataset {}\".format(qc_run_id)\n )\n comment_ts = comment + ts\n comment_ts = textwrap.fill(comment_ts, 70)\n comment_ts = comment_ts.replace(\"\\n\", \"<br/>\")\n\n comments_p = Paragraph(comment_ts, body_style)\n\n avail_height = aH - fig_height - v_padding - comm_h_height\n\n comm_width, comm_height = comments_p.wrap(im_width, avail_height) # aW,\n\n line_widths = comments_p.getActualLineWidths0()\n number_of_lines = len(line_widths)\n if number_of_lines > 1:\n pass\n if number_of_lines == 1:\n min(line_widths)\n comm_width, comm_height = comments_p.wrap(im_width, avail_height)\n\n # Prepare features\n feat_table = Table(\n feature_values,\n colWidths=[clm_width_meta] * len(self.fields),\n hAlign=\"CENTER\",\n rowHeights=0.22 * inch,\n )\n feat_table.setStyle(\n TableStyle(\n [\n (\"FONT\", (0, 0), (-1, 0), \"Helvetica-Bold\"),\n (\"FONT\", (0, 1), (-1, -1), \"Helvetica\"),\n (\"LINEBELOW\", (0, 0), (1, 0), 0.08, colors.black),\n (\"SIZE\", (0, 0), (-1, -1), 8),\n (\"VALIGN\", (0, 0), (-1, -1), \"BOTTOM\"),\n # ('ALIGN', (0, 0), (-1, 0), 'CENTER'),\n (\"ALIGN\", (0, 0), (0, -1), \"LEFT\"),\n (\"ALIGN\", (1, 1), (1, -1), \"LEFT\"),\n (\"INNERGRID\", (0, 0), (-1, -1), 0.08, colors.beige),\n # ('BOX', (0,0), (-1,-1), 0.25, colors.grey),\n ]\n )\n )\n avail_height = aH - meta_height # fig_height - v_padding - comm_h_height\n avail_height -= comm_height\n feat_width, feat_height = feat_table.wrap(aW - im_width, avail_height)\n\n # Draw everyting on canvas\n\n header.drawOn(c, left_margin, aH - top_margin)\n\n c.drawImage(\n img,\n left_margin,\n aH - top_margin - fig_height - v_padding,\n width=fig_width * 1.1,\n height=fig_height * 1.1,\n mask=\"auto\",\n )\n\n meta_table.drawOn(\n c,\n left_margin + fig_width + h_padding,\n aH - meta_height - top_margin / 2, # - v_padding\n )\n\n comments_header.drawOn(\n c,\n left_margin,\n aH\n - top_margin\n - comm_h_height\n - fig_height\n - 2 * v_padding, # - add_on_height\n )\n\n comments_p.drawOn(\n c,\n left_margin,\n aH\n - top_margin\n - comm_h_height\n - comm_height\n - fig_height\n - 2 * v_padding\n - comm_h_height, # - add_on_height\n )\n\n feat_table.drawOn(\n c,\n left_margin + fig_width + h_padding,\n aH - meta_height - top_margin / 2 - feat_height - v_padding,\n # top_margin - fig_height - 2*v_padding - feat_height\n )\n\n # new page\n c.showPage()\n c.saveState()\n\n c.save()","def generate():\n\n # Verify if directory exists\n if not os.path.isdir(config.techniques_markdown_path):\n os.mkdir(config.techniques_markdown_path)\n\n #Write the technique index.html page\n with open(os.path.join(config.techniques_markdown_path, \"overview.md\"), \"w\", encoding='utf8') as md_file:\n md_file.write(config.technique_overview_md)\n\n for domain in config.domains:\n generate_domain_markdown(domain)"],"string":"[\n \"def generate_documentation(self):\\n self.generate_api_docs()\\n build.main([\\n self.SOURCE_DIR,\\n self.BUILD_DIR,\\n ])\",\n \"def build_docs(context, site_name=None, view=True, assume_yes=False):\\n logger.debug(\\\"Starting cli.datasource.build_docs\\\")\\n\\n if site_name is not None:\\n site_names = [site_name]\\n else:\\n site_names = None\\n index_page_locator_infos = context.build_data_docs(\\n site_names=site_names, dry_run=True\\n )\\n\\n msg = \\\"\\\\nThe following Data Docs sites will be built:\\\\n\\\\n\\\"\\n for site_name, index_page_locator_info in index_page_locator_infos.items():\\n msg += \\\" - <cyan>{}:</cyan> \\\".format(site_name)\\n msg += \\\"{}\\\\n\\\".format(index_page_locator_info)\\n\\n cli_message(msg)\\n if not assume_yes:\\n toolkit.confirm_proceed_or_exit()\\n\\n cli_message(\\\"\\\\nBuilding Data Docs...\\\\n\\\")\\n context.build_data_docs(site_names=site_names)\\n\\n cli_message(\\\"Done building Data Docs\\\")\\n\\n if view:\\n context.open_data_docs(site_name=site_name, only_if_exists=True)\",\n \"def buildDocumentation():\\n helptext = 'usage: build_doc.py <output format> <type of documentation>' \\\\\\n '\\\\n - html: for html output' \\\\\\n '\\\\n - pdf: for pdf output' \\\\\\n '\\\\n\\\\n - all: complete documentation' \\\\\\n '\\\\n - dev: only developer documentation' \\\\\\n '\\\\n - user: only user documentation'\\n if len(sys.argv) != 3:\\n print helptext\\n sys.exit(1)\\n\\n if sys.argv[1] not in ['pdf', 'html']:\\n print helptext\\n sys.exit(1)\\n if sys.argv[2] not in ['all', 'dev', 'user']:\\n print helptext\\n sys.exit(1)\\n\\n copyfile('docs/index_%s.rst.template' % sys.argv[2], 'index.rst') # copy main file into root directory\\n os.system('sphinx-build -b %s -c docs -D master_doc=index . docs/output/%s/%s' % (sys.argv[1], sys.argv[1], sys.argv[2]))\\n os.remove('index.rst') # delete config file from root directory\",\n \"def build():\\n\\tconsole = Console()\\n\\tconsole.clear()\\n\\tconsole.print(BANNER)\\n\\tif not os.path.exists(\\\"dataset.yaml\\\"):\\n\\t\\tclick.clear()\\n\\t\\tconsole.print(\\\"Dataset config file not found\\\\nRun - idt init\\\\n\\\")\\n\\t\\texit(0)\\n\\n\\twith open('dataset.yaml') as f:\\n\\t\\tdata = yaml.load(f, Loader=yaml.FullLoader)\\n\\t\\n\\tclick.clear()\\n\\tconsole.print(\\\"Building [bold blue]{dataset_name}[/bold blue] dataset...\\\\n\\\".format(dataset_name=data['DATASET_NAME']))\\n\\tfor classes in data['CLASSES']:\\n\\t\\tclick.clear()\\n\\t\\tconsole.print('Creating [bold blue]{name} class[/bold blue] \\\\n'.format(name=classes['CLASS_NAME']))\\n\\t\\tsearch_list = classes['SEARCH_KEYWORDS'].split(\\\",\\\")\\n\\t\\tfor keywords in search_list:\\n\\t\\t\\tfactory = SearchEngineFactory(keywords,data['SAMPLES_PER_SEARCH'],classes['CLASS_NAME'],data['RESIZE_METHOD'], data['DATASET_NAME'],data['IMAGE_SIZE'], data['ENGINE'],data['API_KEY'])\\n\\t# Remove corrupt files\\n\\tremove_corrupt(data['DATASET_NAME'])\\n\\n\\t# Create a CSV with dataset info\\n\\tcreate_dataset_csv(data['DATASET_NAME'])\\n\\tclick.clear()\\n\\tconsole.print(\\\"Dataset READY!\\\")\",\n \"def run():\\n build_no_documentation()\\n build_sphinx_build()\\n #build_sphinx_pdf()\\n build_graphviz_files()\",\n \"def build_docs(source, destination, doctrees):\\n sphinx_argv = [\\n '-b', 'html',\\n '-d', doctrees,\\n source,\\n destination]\\n\\n sphinx_main(['sphinx-build'] + sphinx_argv)\",\n \"def main():\\n # We know that qidoc build will set the correct cwd\\n qibuild_dir = \\\"..\\\"\\n qibuild_dir = os.path.abspath(qibuild_dir)\\n this_file = __file__\\n this_dir = os.path.dirname(this_file)\\n cmake_api = os.path.join(this_dir, \\\"../source/advanced/cmake/api\\\")\\n cmake_api = os.path.abspath(cmake_api)\\n if not os.path.exists(cmake_api):\\n os.makedirs(cmake_api)\\n qibuild_cmake = os.path.join(qibuild_dir, \\\"cmake\\\", \\\"qibuild\\\")\\n for filename in DOCUMENTED_FILES:\\n cmake_file = os.path.join(qibuild_cmake, filename + \\\".cmake\\\")\\n rst_file = os.path.join(cmake_api, filename + \\\".rst\\\")\\n gen_cmake_doc(cmake_file, rst_file)\",\n \"def build_docs(open_docs):\\n python_call(\\\"pip\\\", [\\\"install\\\", \\\"src/[docs]\\\"])\\n python_call(\\\"pip\\\", [\\\"install\\\", \\\"-r\\\", \\\"src/requirements.txt\\\"])\\n python_call(\\n \\\"ipykernel\\\", [\\\"install\\\", \\\"--user\\\", \\\"--name=za_covid_map\\\"]\\n )\\n shutil.rmtree(\\\"docs/build\\\", ignore_errors=True)\\n call(\\n [\\n \\\"sphinx-apidoc\\\",\\n \\\"--module-first\\\",\\n \\\"-o\\\",\\n \\\"docs/source\\\",\\n \\\"src/za_covid_map\\\",\\n ]\\n )\\n call([\\\"sphinx-build\\\", \\\"-M\\\", \\\"html\\\", \\\"docs/source\\\", \\\"docs/build\\\", \\\"-a\\\"])\\n if open_docs:\\n docs_page = (Path.cwd() / \\\"docs\\\" / \\\"build\\\" / \\\"html\\\" / \\\"index.html\\\").as_uri()\\n secho(\\\"Opening {}\\\".format(docs_page))\\n webbrowser.open(docs_page)\",\n \"def project():\",\n \"def project():\",\n \"def project():\",\n \"def build():\",\n \"def build_documents(self, *args, **kwargs):\\n docs_manager = self._documents_manager\\n resources_tree = self._resources_manager.resources_tree\\n return docs_manager.build_documents(resources_tree, *args, **kwargs)\",\n \"def build_data(self):\\n\\n _header_ = self._header_ + 'build_data(): '\\n\\n if self.verbose:\\n print(_header_ + 'Building data for %s ...' % self.p_data)\\n\\n self.read_data()\\n self.map_data()\\n self.partition_data()\\n self.composition()\\n\\n if self.verbose:\\n print(_header_ + 'Build complete.')\\n\\n return self\",\n \"def build_docs():\\n docs = []\\n for base_id in range(DOCUMENTS_PER_LEVEL):\\n d = jina_pb2.Document()\\n d.granularity = 0\\n d.adjacency = 0\\n d.id = base_id\\n docs.append(d)\\n iterate_build(d, 0, 2, 0, 2)\\n return docs\",\n \"def copy_project_docs(srctree):\\n docdir = os.path.join(srctree, 'Doc')\\n\\n # This block shouldn't be here, but I do not yet know how to\\n # embed this in ReST files.\\n extra_info = {}\\n if os.path.exists(os.path.join(docdir, 'website.lst')):\\n fd = open(os.path.join(docdir, 'website.lst'))\\n for ln in fd.readlines():\\n if ln.startswith('#'): continue\\n fields = ln.split(',')\\n extra_info[fields[0].strip()] = {\\n 'section': fields[1].strip(),\\n 'priority': int(fields[2].strip()),\\n }\\n\\n docs = [ os.path.join(docdir, fn)\\n for fn in os.listdir(docdir) if fn.endswith('.txt') ]\\n docs.append(os.path.join(srctree, 'Install.txt'))\\n docs.append(os.path.join(srctree, 'NEWS.txt'))\\n docs.append(os.path.join(docdir, 'tutorial', 'tutorial.txt'))\\n docs.append(os.path.join(docdir, 'tutorial_embed', 'extending_objc_with_python.txt'))\\n NAMES = {\\n os.path.join(srctree, 'Examples', '00ReadMe.txt') : 'Examples.txt',\\n }\\n docs.extend(NAMES)\\n\\n alldocs = {}\\n\\n for fname in docs:\\n print \\\"-\\\", fname\\n docinfo = {}\\n\\n bn = NAMES.get(fname)\\n if bn is None:\\n bn = os.path.split(fname)[-1]\\n if bn in ('index.txt', 'announcement.txt'):\\n continue\\n if extra_info.has_key(bn):\\n docinfo.update(extra_info[bn])\\n\\n if bn.endswith('.txt'):\\n bn = bn[:-3].lower() + \\\"php\\\"\\n else:\\n bn = bn.lower() + '.php'\\n fd = open(fname)\\n input = fd.read()\\n fd.close()\\n output = docutils.core.publish_string(\\n source = input,\\n source_path = fname,\\n destination_path = bn,\\n writer_name = 'hthtml')\\n \\n output_lines = output.split('\\\\n')\\n for i in range(len(output_lines)):\\n if output_lines[i] == '':\\n break\\n idx = output_lines[i].find(':')\\n if idx == -1:\\n break\\n\\n key = output_lines[i][:idx].strip()\\n value = output_lines[i][idx+1:].strip()\\n docinfo[key] = value\\n\\n output = '\\\\n'.join(output_lines[i:])\\n if not docinfo.has_key('title'):\\n docinfo['title'] = bn\\n alldocs[bn] = docinfo\\n \\n fd = open(os.path.join('docroot', 'doc', bn), 'w')\\n fd.write(PHP_HEADER%docinfo)\\n\\n fd.write(output);\\n\\n fd.write(PHP_FOOTER)\\n\\n # Calculate indices for user and developer documentation\\n docs = alldocs.keys()\\n developer_docs = []\\n user_docs = []\\n\\n for doc in alldocs:\\n if not alldocs[doc].has_key('section'):\\n print \\\"Skipping\\\", doc\\n continue\\n\\n if alldocs[doc]['section'] == 'user':\\n user_docs.append([alldocs[doc]['title'], doc])\\n elif alldocs[doc]['section'] == 'developer':\\n developer_docs.append([alldocs[doc]['title'], doc])\\n\\n def doccmp(a, b):\\n r = cmp(alldocs[a[1]]['priority'], alldocs[b[1]]['priority'])\\n if r != 0: return r\\n\\n return cmp(a[1], b[1])\\n user_docs.sort(doccmp)\\n developer_docs.sort(doccmp)\\n \\n # Rewrite the indices (substitute the current document lists)\\n for fname in ('index.php', 'usage.php', 'developer.php'):\\n fd = open(os.path.join('docroot', 'doc', fname), 'r')\\n index_php = fd.readlines()\\n fd.close()\\n\\n fd = open(os.path.join('docroot', 'doc', fname), 'w')\\n skip = 0\\n for ln in index_php:\\n if not skip:\\n fd.write(ln)\\n if ln.find('/USERDOC') != -1:\\n skip = 0\\n fd.write(ln)\\n elif ln.find('USERDOC') != -1:\\n skip = 1\\n for title, link in user_docs:\\n fd.write('<LI><A HREF=\\\"%s\\\">%s</A>\\\\n'%(link, title))\\n if ln.find('/DEVDOC') != -1:\\n skip = 0\\n fd.write(ln)\\n elif ln.find('DEVDOC') != -1:\\n skip = 1\\n for title, link in developer_docs:\\n fd.write('<LI><A HREF=\\\"%s\\\">%s</A>\\\\n'%(link, title))\\n\\n EXAMPLES = os.path.join('docroot', 'doc', 'examples.php')\\n OUTEXAMPLES = os.path.join('docroot', 'examples', 'index.php')\\n replace_examples_svn(EXAMPLES)\\n if os.path.exists(OUTEXAMPLES):\\n os.unlink(OUTEXAMPLES)\\n shutil.copyfile(EXAMPLES, OUTEXAMPLES)\\n\\n # Copy tutorial files\\n TUTORIAL_ENDINGS = ['.nib', '.py', '-src', '.h', '.m']\\n tutdir = os.path.join(docdir, 'tutorial')\\n files = os.listdir(tutdir)\\n replacements = []\\n for fn in files:\\n for ext in TUTORIAL_ENDINGS:\\n if fn.endswith(ext):\\n dstname = os.path.join('docroot', 'doc', fn)\\n replacements.append(copy_tutorial_file(fn, tutdir, dstname))\\n break\\n replace_tutorial_zips(os.path.join('docroot', 'doc', 'tutorial.php'), replacements)\\n \\n tutdir = os.path.join(docdir, 'tutorial_embed', 'src')\\n files = os.listdir(tutdir)\\n if not os.path.exists(os.path.join('docroot', 'doc', 'src')):\\n os.mkdir(os.path.join('docroot', 'doc', 'src'))\\n for fn in files:\\n for ext in TUTORIAL_ENDINGS:\\n if fn.endswith(ext):\\n dstname = os.path.join('docroot', 'doc', 'src', fn)\\n replacements.append(copy_tutorial_file(fn, tutdir, dstname))\\n break\\n replace_tutorial_zips(os.path.join('docroot', 'doc', 'tutorial.php'), replacements)\\n\\n #print \\\"Don't forget to update docroot/doc/tutorial.php: it's references to\\\"\\n #print \\\"'step3-MainMenu.nib' and 'step12-src' should be changed to ZIP files\\\"\",\n \"def _sphinx_build(self, kind: str):\\n if kind not in (\\\"html\\\", \\\"latex\\\"):\\n raise ValueError(f\\\"kind must be html or latex, not {kind}\\\")\\n\\n cmd = [\\\"sphinx-build\\\", \\\"-b\\\", kind]\\n if self.num_jobs:\\n cmd += [\\\"-j\\\", self.num_jobs]\\n if self.warnings_are_errors:\\n cmd += [\\\"-W\\\", \\\"--keep-going\\\"]\\n if self.verbosity:\\n cmd.append(f\\\"-{'v' * self.verbosity}\\\")\\n cmd += [\\n \\\"-d\\\",\\n os.path.join(BUILD_PATH, \\\"doctrees\\\"),\\n SOURCE_PATH,\\n os.path.join(BUILD_PATH, kind),\\n ]\\n return subprocess.call(cmd)\",\n \"def _sphinx_build(self, kind: str):\\n if kind not in (\\\"html\\\", \\\"latex\\\"):\\n raise ValueError(f\\\"kind must be html or latex, not {kind}\\\")\\n\\n cmd = [\\\"sphinx-build\\\", \\\"-b\\\", kind]\\n if self.num_jobs:\\n cmd += [\\\"-j\\\", self.num_jobs]\\n if self.warnings_are_errors:\\n cmd += [\\\"-W\\\", \\\"--keep-going\\\"]\\n if self.verbosity:\\n cmd.append(f\\\"-{'v' * self.verbosity}\\\")\\n cmd += [\\n \\\"-d\\\",\\n os.path.join(BUILD_PATH, \\\"doctrees\\\"),\\n SOURCE_PATH,\\n os.path.join(BUILD_PATH, kind),\\n ]\\n return subprocess.call(cmd)\",\n \"def doc(self):\\n from distutils.dir_util import copy_tree\\n\\n def copy_tree_checker(src, dst):\\n \\\"\\\"\\\"Wrap copy_tree to avoid pydoit error.\\\"\\\"\\\"\\n copy_tree(src, dst)\\n return True\\n\\n return {\\n \\\"actions\\\": [\\n (create_dir, [\\\"build/doc/source\\\"]),\\n (copy_tree_checker, [\\\"docs\\\", \\\"build/doc/source\\\"]),\\n TaskCreator.get_sphinx() + \\\"-apidoc -o build/doc/source --force --separate --module-first \\\" + self.project_name_sc,\\n TaskCreator.get_sphinx() + \\\"-build -j auto -n build/doc/source build/doc/html\\\"\\n ],\\n \\\"verbosity\\\": 2\\n }\",\n \"def build_document(self):\\n pass\",\n \"def createFakeSphinxProject(self):\\n self.sourceDir.child(\\\"conf.py\\\").setContent(self.confContent.encode())\\n self.sourceDir.child(\\\"index.rst\\\").setContent(self.indexContent.encode())\",\n \"def getProjectData(self) -> ghidra.framework.model.ProjectData:\\n ...\",\n \"def docs():\\n sh('sphinx-build -W -b html docs docs/_build/html')\",\n \"def makeDocFile(self):\\n\\n f_out = \\\"%s/%s-doc.php\\\" % (self.dir_out, self.project_id)\\n version = max(self.versions)\\n\\n with open(f_out, 'w') as f:\\n f.write(\\\"<!DOCTYPE html>\\\\n\\\" \\\\\\n \\\"<html xmlns=\\\\\\\"http://www.w3.org/1999/xhtml\\\\\\\">\\\\n\\\" \\\\\\n \\\"<head>\\\\n\\\" \\\\\\n \\\"<meta http-equiv=\\\\\\\"Content-Type\\\\\\\" content=\\\\\\\"text/html; charset=utf-8\\\\\\\"/>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"<title>Kit&Pack − Ultimate Power Booster</title>\\\\n\\\" \\\\\\n \\\"<link rel=\\\\\\\"shortcut icon\\\\\\\" type=\\\\\\\"image/png\\\\\\\" href=\\\\\\\"../favicon.png\\\\\\\"/>\\\" \\\\\\n \\\"<link rel=\\\\\\\"stylesheet\\\\\\\" type=\\\\\\\"text/css\\\\\\\" href=\\\\\\\"../css/doc-2.css\\\\\\\" />\\\\n\\\"\\n \\\"\\\\n\\\" \\\\\\n \\\"</head>\\\\n\\\" \\\\\\n \\\"<body>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"<h1>Ultimate Power Booster</h1>\\\" \\\\\\n \\\"\\\\n\\\")\\n\\n # Write a list of other versions of the documentation\\n f.write(\\\"<p>Versions de cette documentation.</p>\\\\n\\\")\\n f.write(\\\"<ul>\\\\n\\\")\\n for v in self.versions:\\n f.write(\\\"\\\\t<li><a href=\\\\\\\"%s.php\\\\\\\">%s</a></li>\\\\n\\\" % (\\n v, v))\\n f.write(\\\"</ul>\\\\n\\\\n\\\")\\n\\n f.write(\\\"<?php\\\\n\\\" \\\\\\n \\\"include(\\\\\\\"%s.php\\\\\\\")\\\\n\\\" \\\\\\n \\\"?>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"</body>\\\\n\\\" \\\\\\n \\\"</html>\\\" % (version))\",\n \"def generate_build_document(self, commit_info, manifest_info):\\n\\n manifest_path, commit = commit_info\\n build_name = manifest_info.name\\n logging.info(f'Generating build document for manifest {build_name}...')\\n\\n # See if build document already is in the database and extract\\n # for updating if so, otherwise create a new dictionary for\\n # population\\n try:\\n build_data = self.db.get_document(build_name)\\n except cbdatabase_db.NotFoundError:\\n build_data = dict(type='build', key_=build_name)\\n\\n projects = dict()\\n\\n for project_name in manifest_info.get_projects():\\n project_shas = manifest_info.get_project_shas(\\n project_name\\n )\\n projects[project_name] = [\\n f'{project_name}-{sha}' for sha in project_shas\\n ]\\n build_data['manifest'] = projects\\n build_data['invalid_shas'] = dict() # Populated (potentially) later\\n\\n release_keys = ('product', 'release', 'version', 'build_num')\\n release_data = manifest_info.get_release_info()\\n product, release, version, build_num = release_data\\n build_data.update(dict(zip(release_keys, release_data)))\\n\\n index_key = f'{product}-{version}'\\n build_data['prev_build_num'] = (\\n self.prod_ver_index.get(index_key, None)\\n )\\n\\n build_data['commits'] = list() # Populated (potentially) later\\n build_data['manifest_sha'] = commit.id.decode()\\n build_data['manifest_path'] = manifest_path.decode()\\n build_data['timestamp'] = commit.commit_time\\n build_data['download_url'] = (\\n f'http://latestbuilds.service.couchbase.com/builds/latestbuilds/'\\n f'{product}/{release}/{build_num}'\\n )\\n\\n # Used for related (external) data; preserve any existing data\\n build_data['metadata'] = build_data.get('metadata', dict())\\n\\n logging.debug(f\\\"Final build document: {build_data}\\\")\\n self.db.upsert_documents({build_name: build_data})\\n\\n self.first_prod_ver_build = (\\n True if build_data['prev_build_num'] is None else False\\n )\\n self.prod_ver_index[index_key] = build_num\\n self.db.update_product_version_index(self.prod_ver_index)\\n\\n return build_data\",\n \"def build(self) -> None:\\n\\n print(\\\"Genereting files..\\\")\\n self.doc = self.doc + r'\\\\end{document}'\\n\\n f = open(\\\"latex\\\\\\\\\\\" + self.report_name + '.tex', 'w')\\n f.write(self.doc)\\n f.close()\\n\\n os.chdir('latex')\\n\\n cmd = ['pdflatex', '-interaction', 'nonstopmode', self.report_name + '.tex']\\n #cmd = ['pdflatex', '-interaction', self.report_name + '.tex']\\n\\n for i in range(2):\\n proc = subprocess.Popen(cmd)\\n proc.communicate()\\n retcode = proc.returncode\\n if not retcode == 0:\\n os.chdir('..')\\n raise ValueError('Error {} executing command: {}'.format(retcode, ' '.join(cmd)))\\n\\n os.unlink(self.report_name + '.aux')\\n os.unlink(self.report_name + '.lof')\\n os.unlink(self.report_name + '.log')\\n os.unlink(self.report_name + '.lot')\\n os.unlink(self.report_name + '.out')\\n os.unlink(self.report_name + '.toc')\\n\\n os.chdir('..')\",\n \"def build_docs(session):\\n envbindir = session.bin\\n session.install(\\\"-e\\\", \\\".[all,docs]\\\")\\n with session.chdir(\\\"docs/\\\"):\\n session.run(\\n \\\"sphinx-autobuild\\\",\\n \\\"-j\\\",\\n \\\"auto\\\",\\n \\\"--open-browser\\\",\\n \\\"-qT\\\",\\n \\\".\\\",\\n f\\\"{envbindir}/../tmp/html\\\",\\n )\",\n \"def build(self, file_number, data):\\n pass\",\n \"def test_subProjectDocBuilding(self):\\n loreInput, loreOutput = self.getArbitraryLoreInputAndOutput(\\\"0.3.0\\\")\\n manInput = self.getArbitraryManInput()\\n manOutput = self.getArbitraryManHTMLOutput(\\\"0.3.0\\\", \\\"../howto/\\\")\\n structure = {\\n \\\"LICENSE\\\": \\\"copyright!\\\",\\n \\\"twisted\\\": {\\\"web\\\": {\\\"__init__.py\\\": \\\"import WEB\\\",\\n \\\"topfiles\\\": {\\\"setup.py\\\": \\\"import WEBINST\\\"}}},\\n \\\"doc\\\": {\\\"web\\\": {\\\"howto\\\": {\\\"index.xhtml\\\": loreInput},\\n \\\"man\\\": {\\\"twistd.1\\\": manInput}},\\n \\\"core\\\": {\\\"howto\\\": {\\\"template.tpl\\\": self.template}}\\n }\\n }\\n\\n outStructure = {\\n \\\"LICENSE\\\": \\\"copyright!\\\",\\n \\\"setup.py\\\": \\\"import WEBINST\\\",\\n \\\"twisted\\\": {\\\"web\\\": {\\\"__init__.py\\\": \\\"import WEB\\\"}},\\n \\\"doc\\\": {\\\"howto\\\": {\\\"index.html\\\": loreOutput},\\n \\\"man\\\": {\\\"twistd.1\\\": manInput,\\n \\\"twistd-man.html\\\": manOutput}}}\\n\\n self.createStructure(self.rootDir, structure)\\n\\n outputFile = self.builder.buildSubProject(\\\"web\\\", \\\"0.3.0\\\")\\n\\n self.assertExtractedStructure(outputFile, outStructure)\",\n \"def test_build(self):\\n self.createFakeSphinxProject()\\n self.builder.build(self.sphinxDir)\\n self.verifyBuilt()\",\n \"def update_docs():\\n site_path = os.path.join(PROJECTS_ROOT, CURRENT_SITE)\\n docs_path = os.path.join(site_path, 'doc_src')\\n with cd(docs_path):\\n run('git reset --hard && git pull --all')\\n run('workon djangopatterns && cd doc_src && make clean')\\n run('workon djangopatterns && cd doc_src && make json')\",\n \"def create_dbs_for_project(self):\\r\\n assert self.index\\r\\n self.client.indices.create(self.index, ignore=400)\\r\\n bug_mapping = {\\r\\n \\\"bug\\\": {\\r\\n \\\"_id\\\": {\\r\\n \\\"path\\\": \\\"bugid\\\"\\r\\n },\\r\\n \\\"_timestamp\\\": {\\r\\n \\\"enabled\\\": True,\\r\\n \\\"path\\\": \\\"openedDate\\\",\\r\\n \\\"format\\\": \\\"dateOptionalTime\\\"\\r\\n },\\r\\n \\\"properties\\\": {\\r\\n \\\"openedDate\\\": {\\r\\n \\\"type\\\": \\\"date\\\",\\r\\n \\\"format\\\": \\\"dateOptionalTime\\\"\\r\\n }\\r\\n }\\r\\n }\\r\\n }\\r\\n self.client.indices.put_mapping(index=self.index,\\r\\n doc_type=ElasticSearch.BUGS, body=bug_mapping)\\r\\n generated_mapping = {\\r\\n \\\"generated\\\" : {\\r\\n \\\"properties\\\" : {\\r\\n \\\"data.tar.gz\\\" : {\\r\\n \\\"type\\\" : \\\"string\\\",\\r\\n \\\"index\\\" : \\\"no\\\",\\r\\n \\\"norms\\\" : {\\r\\n \\\"enabled\\\" : False\\r\\n }\\r\\n }\\r\\n }\\r\\n }\\r\\n }\\r\\n self.client.indices.put_mapping(index=self.index,\\r\\n doc_type=ElasticSearch.GENERATED, body=generated_mapping)\",\n \"def makedocs(projectfolder):\\n featuremodel_path = path.join(projectfolder, \\\"productline\\\", \\\"model.xml\\\")\\n configs_path = path.join(projectfolder, \\\"productline\\\", \\\"configs\\\")\\n bddfeatures_path = path.join(projectfolder, \\\"bddfeatures\\\")\\n testreports_path = path.join(projectfolder, \\\"testreports\\\")\\n\\n fmparser = parsers.FeatureModelParser()\\n resultsparser = parsers.TestResultsParser()\\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\\n\\n docs_dir = path.join(projectfolder, \\\"docs/generated\\\")\\n if path.exists(docs_dir):\\n shutil.rmtree(docs_dir)\\n makedirs(docs_dir)\\n\\n lektor_templates_path = \\\"doc_templates\\\"\\n utilities.sed_inplace(\\n path.join(lektor_templates_path, \\\"aplet.lektorproject\\\"),\\n r'<<PROJECT>>',\\n CONFIG[\\\"project_name\\\"])\\n\\n products = {}\\n product_names = get_product_names_from_configs_path(configs_path)\\n for product_name in product_names:\\n productconfig_filepath = path.join(projectfolder, \\\"productline/configs\\\", product_name + \\\".config\\\")\\n product_html_report_name = \\\"report{0}.html\\\".format(product_name)\\n product_html_results_src = path.join(testreports_path, product_html_report_name)\\n product_xml_report_name = \\\"report{0}.xml\\\".format(product_name)\\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\\n\\n with open(productconfig_filepath, \\\"r\\\") as productconfig_file:\\n products[product_name] = {}\\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\\n\\n current_product_lektor_dir = path.join(lektor_templates_path, \\\"content/products\\\", product_name)\\n if not path.exists(current_product_lektor_dir):\\n makedirs(current_product_lektor_dir)\\n\\n product_filepath = path.join(current_product_lektor_dir,\\\"contents.lr\\\")\\n shutil.copyfile(path.join(lektor_templates_path, \\\"helpers/product_contents.lr\\\"), product_filepath)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\\n product_features = configparser.parse_config(productconfig_filepath)\\n feature_model.trim_based_on_config(product_features)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \\\"feature_model\\\")\\n\\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\\n product_test_status = feature_model.root_feature.test_status\\n utilities.sed_inplace(product_filepath, \\\"<<TEST_STATUS>>\\\", product_test_status.name)\\n\\n # Copy test run html report to generated docs\\n if path.exists(product_html_results_src):\\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\\n\\n click.echo(\\\"- Generating feature model SVG...\\\")\\n click.echo(featuremodel_path)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \\\"content/\\\"), \\\"feature_model\\\")\\n\\n click.echo(\\\"- Building site\\\")\\n lektor_cmd = [\\\"lektor\\\", \\\"--project\\\", lektor_templates_path, \\\"build\\\", \\\"-O\\\", path.abspath(docs_dir)]\\n click.echo(\\\"Running: \\\" + subprocess.list2cmdline(lektor_cmd))\\n subprocess.call(lektor_cmd)\\n\\n product_map_renderer = mapbuilder.ProductMapRenderer()\\n productline_generated_filepath = path.join(docs_dir, \\\"index.html\\\")\\n html = product_map_renderer.get_productmap_html(feature_model, products)\\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)\",\n \"def build_docs(branch):\\n os.chdir(os.path.join(gitdname, 'docs'))\\n sphinx_dir = os.path.join(virtual_dir,'bin')\\n retcode = subprocess.call(\\\"make clean\\\", shell=True)\\n if retcode != 0:\\n os.chdir(dname)\\n msg = \\\"\\\"\\\"Could not clean the html docs for branch %s\\\"\\\"\\\" % branch\\n raise Exception(msg)\\n #NOTE: The python call in the below makes sure that it uses the Python\\n # that is referenced after entering the virtualenv\\n sphinx_call = \\\" \\\".join(['make','html',\\n \\\"SPHINXBUILD=' python /usr/local/bin/sphinx-build'\\\"])\\n activate = os.path.join(virtual_dir, \\\"bin\\\", \\\"activate\\\")\\n activate_virtualenv = \\\". \\\" + activate\\n #NOTE: You have to enter virtualenv in the same call. As soon as the\\n # child process is done, the env variables from activate are lost.\\n # getting the correct env from bin/activate and passing to env is\\n # annoying\\n retcode = subprocess.call(\\\" && \\\".join([activate_virtualenv, sphinx_call]),\\n shell=True,\\n env = {'MATPLOTLIBRC' : # put this in the environment to use local rc\\n '/home/skipper/statsmodels/statsmodels/tools/',\\n # Need this for my openblas setup on my laptop\\n 'LD_LIBRARY_PATH' : os.getenv('LD_LIBRARY_PATH')})\\n\\n if retcode != 0:\\n os.chdir(dname)\\n msg = \\\"\\\"\\\"Could not build the html docs for branch %s\\\"\\\"\\\" % branch\\n raise Exception(msg)\\n os.chdir(dname)\",\n \"def generate_patch_build(self, domain):\\n # TODO change name of def\\n base_path = self.paths[\\\"api_doc_dir\\\"]\\n self.generate_apidoc_patches()\\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\\n patch_generator.filter_for_deleted_apis()\\n\\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\\n\\n output = process.communicate()[0]\\n if output:\\n\\n with open(self.paths[\\\"base_dir\\\"] + \\\"/apidoc.json\\\", 'w') as outfile:\\n apidoc_content = {\\\"url\\\": \\\"https://ib-backend-dev.apigateway.in\\\",\\n \\\"version\\\": \\\"0.0.1\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"name\\\": \\\"iBHubs_backend API Documentation\\\",\\n \\\"title\\\": \\\"iBHubs_backend Documenation\\\"}\\n json.dump(apidoc_content, outfile, indent=4)\\n # by default we assume user is working at no specific branch so we fix\\n # url to default above url as above , then we check if any specific parametr is given\\n # and replace url with required url\\n if domain != '' and domain:\\n with open(self.paths[\\\"apidoc\\\"]) as src_json:\\n apidoc_content = json.load(src_json)\\n apidoc_content['url'] = \\\"https://\\\" + domain\\n with open(self.paths[\\\"apidoc\\\"], 'w') as outfile:\\n json.dump(apidoc_content, outfile, indent=4)\\n try:\\n os.mkdir(\\\"docs\\\")\\n except OSError:\\n pass\\n # the below command is responsible for creating docs\\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\\n '-o', os.path.join(self.base_dir, 'docs'),\\n '-e', 'django_swagger_utils/*',\\n '-e', 'static/*',\\n ], stdout=subprocess.PIPE)\\n print process.communicate()[0]\\n ################################################\\n # hosting apidoc\\n ################################################\\n # obtaining the path of static folder of django-swagger-utils\\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"../..\\\"))\\n # static_folder_path = os.path.join(django_swagger_utils_path, \\\"static\\\")\\n # import shutil\\n # # create a folder apidoc , delete if previously exists\\n # if os.path.exists(os.path.join(static_folder_path, \\\"apidoc\\\")):\\n # shutil.rmtree(os.path.join(static_folder_path, \\\"apidoc\\\"))\\n # apidoc_path = os.path.join(static_folder_path, \\\"apidoc\\\")\\n #\\n # os.mkdir(apidoc_path)\\n\\n # from distutils.dir_util import copy_tree\\n # copydocs from docs to apidoc in swagger utils\\n # try:\\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\\n # except Exception as err:\\n # print err\\n\\n # browse to localhost:<port>/static/apidoc/index.html\\n\\n else:\\n raise CommandError(\\\"Help: Install apidoc: [ sudo npm install -g apidoc ]\\\")\",\n \"def _createDataFromProject(self):\\n data = []\\n project_dict = self._project.asDict()\\n for phase_id, phase_dict in project_dict['phases'].items():\\n for fitable_id, fitable_dict in phase_dict['cell'].items():\\n data.append({\\n 'id': ['phases', phase_id, 'cell', fitable_id],\\n 'label': '{} {}'.format(phase_id, fitable_id),\\n 'value': fitable_dict['value'],\\n 'error': fitable_dict['error'],\\n 'refine': fitable_dict['refine']\\n })\\n return data\",\n \"def get_data(self, **kwargs):\\n\\n self.data = {}\\n #node_data = ''\\n #link_data = ''\\n templates_data = self.request_from_server('templates')\\n self.templates = templates_data\\n project_data = self.request_from_server('projects')\\n for project in project_data:\\n project_name = project['name']\\n if 'project_name' in kwargs:\\n if project_name != kwargs['project_name']:\\n continue\\n\\n self.data[project_name] = {}\\n self.data[project_name]['project_id'] = project['project_id']\\n self.data[project_name]['nodes'] = {}\\n node_data = self.request_from_server('projects/{}/nodes'.format(project['project_id']))\\n link_data = self.request_from_server('projects/{}/links'.format(project['project_id']))\\n for node in node_data:\\n node_name = node['name']\\n self.data[project_name]['nodes'][node_name] = {}\\n self.data[project_name]['nodes'][node_name]['node_id'] = node['node_id']\\n self.data[project_name]['nodes'][node_name]['template_id'] = node['template_id']\\n self.data[project_name]['nodes'][node_name]['node_type'] = node['node_type']\\n self.data[project_name]['nodes'][node_name]['console_port'] = node['console']\\n self.data[project_name]['nodes'][node_name]['console_session'] = None\\n self.data[project_name]['nodes'][node_name]['x'] = node['x']\\n self.data[project_name]['nodes'][node_name]['y'] = node['y']\\n self.data[project_name]['nodes'][node_name]['ports'] = {}\\n if project['status'] != 'closed':\\n self.data[project_name]['nodes'][node_name]['status'] = node['status']\\n for port in node['ports']:\\n port_name = port['short_name']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name] = {}\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['adapter_number'] = port['adapter_number']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['port_number'] = port['port_number']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_type'] = port['link_type']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_id'] = None\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['in_use'] = False\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = None\\n for link in link_data:\\n for link_node in link['nodes']:\\n if node['node_id'] == link_node['node_id']:\\n if link_node['label']['text'] == port_name:\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['link_id'] = link['link_id']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['in_use'] = True\\n if link['nodes'].index(link_node) == 0:\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to_id'] = link['nodes'][1]['node_id']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = self.get_node_name_from_id(project_name,link['nodes'][1]['node_id'])\\n else:\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to_id'] = link['nodes'][0]['node_id']\\n self.data[project_name]['nodes'][node_name]['ports'][port_name]['connected_to'] = self.get_node_name_from_id(project_name,link['nodes'][0]['node_id'])\",\n \"def build(_):\",\n \"def build(\\n ctx,\\n skip,\\n enable_doxygen_conf,\\n enable_doxygen,\\n enable_symlinks,\\n enable_sphinx,\\n use_doxygen_conf_in,\\n doxygen_conf_defaults_path,\\n dox,\\n skip_dox,\\n warning_is_error,\\n nitpicky,\\n):\\n root_project_dir = discover_conf_py_directory(ctx.obj[\\\"root_project_dir\\\"])\\n\\n if doxygen_conf_defaults_path is not None:\\n _doxygen_conf_defaults_path = Path(doxygen_conf_defaults_path)\\n else:\\n _doxygen_conf_defaults_path = None\\n\\n return_code = build_stack_docs(\\n root_project_dir,\\n skipped_names=skip,\\n prefer_doxygen_conf_in=use_doxygen_conf_in,\\n doxygen_conf_defaults_path=_doxygen_conf_defaults_path,\\n enable_doxygen_conf=enable_doxygen_conf,\\n enable_doxygen=enable_doxygen,\\n enable_package_links=enable_symlinks,\\n enable_sphinx=enable_sphinx,\\n select_doxygen_packages=dox,\\n skip_doxygen_packages=skip_dox,\\n warning_is_error=warning_is_error,\\n nitpicky=nitpicky,\\n )\\n if return_code > 0:\\n sys.exit(return_code)\",\n \"def read_doc(self):\\n self.data_read[:] = []\\n for para in self.document.paragraphs:\\n text = para.text\\n # skip blank lines\\n if text.strip():\\n # remove duplicated spaces\\n text = ' '.join(text.split())\\n # for older versions of final CAPA's\\n self.fill_project_info(text, new_format=False)\\n self.data_read.append(text)\\n\\n # Constant in old & new report format\\n # Batch/Project name\\n # Lead(s)'s name\\n # Reported date\\n for i in range(0, len(self.data_read)):\\n if next((x for x in self.leads if x in self.data_read[i]), None):\\n self.project_info.update({'Project Name': self.data_read[i - 1]})\\n self.project_info.update({'Lead(s)': self.data_read[i]})\\n self.project_info.update({'Date Reported': self.data_read[i + 1]})\\n break\",\n \"def build(working_directory, configuration):\\n\\n # Copy README.rst to docs/temp/README.html\\n # Doxygen may not create the output folder, ensure it exists.\\n\\n temp_dir = os.path.join(working_directory, \\\"temp\\\")\\n create_folder_if_needed(temp_dir)\\n\\n # Needed for dot generated docs\\n create_folder_if_needed(os.path.join(temp_dir, \\\"images\\\"))\\n\\n # Process all the .dot files\\n for item in os.listdir(working_directory):\\n\\n # Process the .dot files\\n if _DOT_MATCH.match(item):\\n # Call dot to create the files\\n run_command(\\n (\\\"dot\\\", \\\"-Tpng\\\", item, \\\"-otemp{0}images{0}{1}.png\\\".format(\\n os.sep, item[:-4])),\\n working_dir=working_directory)\\n\\n\\n # Get the input and output file names\\n source = os.path.join(os.path.dirname(working_directory), \\\"README.rst\\\")\\n dest = os.path.join(temp_dir, \\\"README.html\\\")\\n\\n # Was the file already created and newer than the source?\\n if is_source_newer(source, dest):\\n\\n # Load pandoc if needed to do the conversion\\n pypandoc.ensure_pandoc_installed(delete_installer=True)\\n pypandoc.convert_file(source, to=\\\"html\\\", outputfile=dest)\\n return 0\",\n \"def build(self):\\n\\t\\tself.documents = self.get_items_to_index()\\n\\t\\tself.build_index()\",\n \"def build_pdf(branch):\\n os.chdir(os.path.join(gitdname,'statsmodels','docs'))\\n sphinx_dir = os.path.join(virtual_dir,'bin')\\n retcode = subprocess.call(\\\" \\\".join(['make','latexpdf',\\n 'SPHINXBUILD='+sphinx_dir+'/sphinx-build']), shell=True)\\n if retcode != 0:\\n os.chdir(old_cwd)\\n msg = \\\"\\\"\\\"Could not build the pdf docs for branch %s\\\"\\\"\\\" % branch\\n raise Exception(msg)\\n os.chdir(dname)\",\n \"def set_project_values(project, data):\\n project.hashtag = data['hashtag']\\n if 'name' in data and len(data['name']) > 0:\\n project.name = data['name']\\n else:\\n project.name = project.hashtag.replace('-', ' ')\\n if 'summary' in data and len(data['summary']) > 0:\\n project.summary = data['summary']\\n has_longtext = 'longtext' in data and len(data['longtext']) > 0\\n if has_longtext:\\n project.longtext = data['longtext']\\n if 'autotext_url' in data and data['autotext_url'].startswith('http'):\\n project.autotext_url = data['autotext_url']\\n if not project.source_url or project.source_url == '':\\n project.source_url = data['autotext_url']\\n # MAX progress\\n if 'levelup' in data and 0 < project.progress + data['levelup'] * 10 < 50:\\n project.progress = project.progress + data['levelup'] * 10\\n # return jsonify(data=data)\\n if project.autotext_url is not None and not has_longtext:\\n # Now try to autosync\\n project = AddProjectData(project)\\n return project\",\n \"def build_docs(options):\\r\\n verbose = getattr(options, 'verbose', False)\\r\\n\\r\\n cmd = \\\"cd {dir}; make html quiet={quiet}\\\".format(\\r\\n dir=doc_path(options),\\r\\n quiet=\\\"false\\\" if verbose else \\\"true\\\"\\r\\n )\\r\\n\\r\\n sh(cmd)\",\n \"def build_DB(self, doc_files):\\n\\t\\tcompteur=0\\n\\t\\tdoc_name=doc_files+'doc_'+str(compteur)+'.txt'\\n\\t\\twhile os.path.exists(doc_name):\\n\\t\\t doc=Doc(doc_name)\\n\\t\\t self.DB.add_doc(doc)\\n\\t\\t compteur+=1\\n\\t\\t doc_name=doc_files+'doc_'+str(compteur)+'.txt'\\n\\t\\tprint \\\"Number of documents in the Data Base: \\\", self.DB.nb_doc_total\\n\\t\\t#print self.DB.id2nbword\\n\\t\\tself.dump_DB()\",\n \"def build(self):\\n self.puts(colored.blue(\\\"Building project...\\\"))\\n\\n if os.path.exists(self.build_path):\\n shutil.rmtree(self.build_path)\\n os.makedirs(self.build_path)\\n\\n with indent(2):\\n self._reset_build_sequence_id()\\n self._build_pre_project_template()\\n self._build_project_template()\\n self._build_pre_resources_template()\\n self._build_resources_template()\\n self._build_post_resources_template()\",\n \"def do_build():\\n tmp_dir = Path(tempfile.mkdtemp())\\n (tmp_dir / \\\"integrations-docs.js\\\").write_text(render_js_module(collect_docs(), *collect_metrics(), collect_meta()))\\n\\n symlink_images(tmp_dir)\\n\\n shutil.rmtree(OUT_DIR, ignore_errors=True)\\n tmp_dir.replace(OUT_DIR)\",\n \"def test_project(self, doi_dataset, doi_bib, orcid, metadata_parser):\\n apply_mock(doi_dataset, doi_bib, orcid, metadata_parser)\\n os.chdir(\\\"input/\\\")\\n _set_args(\\\"-i\\\",\\\"yamls/project.yaml\\\",\\\"-o\\\",\\\"../out\\\")\\n with HiddenPrints():\\n ya2ro.main()\\n\\n data = yaml.load(\\\"yamls/project.yaml\\\", Loader=SafeLoader)\\n with open(\\\"../out/project/index-en.html\\\") as f:\\n web = f.read()\\n\\n self.assert_data_in_web(data, web)\",\n \"def main(*, build, subdir, description, supports_modules=False,\\n supports_quick=False):\\n parser = argparse.ArgumentParser(description=description)\\n group = parser.add_mutually_exclusive_group()\\n group.add_argument(\\n \\\"--serve\\\", action='store_true',\\n help=\\\"Serve the documentation on the given PORT for easy preview.\\\")\\n group.add_argument(\\n \\\"--out_dir\\\", type=str, metavar=\\\"DIR\\\",\\n help=\\\"Generate the documentation to the given output directory.\\\"\\n \\\" The DIR must be an absolute path.\\\"\\n \\\" If DIR already exists, then it must be empty.\\\"\\n \\\" (For regression testing, the DIR can be the magic value <test>,\\\"\\n \\\" in which case a $TEST_TMPDIR subdir will be used.)\\\")\\n parser.add_argument(\\n \\\"--port\\\", type=int, metavar=\\\"PORT\\\", default=8000,\\n help=\\\"Use a non-default PORT when serving for preview.\\\")\\n parser.add_argument(\\n \\\"--verbose\\\", action=\\\"store_true\\\",\\n help=\\\"Echo detailed commands, progress, etc. to the console\\\")\\n if supports_modules:\\n parser.add_argument(\\n \\\"module\\\", nargs=\\\"*\\\",\\n help=\\\"Limit the generated documentation to only these modules and \\\"\\n \\\"their children. When none are provided, all will be generated. \\\"\\n \\\"For example, specify drake.math or drake/math for the C++ \\\"\\n \\\"module, or pydrake.math or pydrake/math for the Python module.\\\")\\n if supports_quick:\\n parser.add_argument(\\n \\\"--quick\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Omit from the output items that are slow to generate. \\\"\\n \\\"This yields a faster preview, but the output will be incomplete.\\\")\\n args = parser.parse_args()\\n if args.verbose:\\n global _verbose\\n _verbose = True\\n curried_build = build\\n if supports_modules:\\n canonicalized_modules = [\\n x.replace('/', '.')\\n for x in args.module\\n ]\\n curried_build = functools.partial(\\n curried_build, modules=canonicalized_modules)\\n if supports_quick:\\n curried_build = functools.partial(\\n curried_build, quick=args.quick)\\n if args.out_dir is None:\\n assert args.serve\\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\\n else:\\n _do_generate(build=curried_build, out_dir=args.out_dir,\\n on_error=parser.error)\",\n \"def dataComponent_build(self, **kwargs):\\n\\n str_path = '/'\\n str_plugin = 'PACSPull'\\n ft_convertFrom = None\\n str_convertTo = ''\\n SeriesFilesCount = 3\\n dataTree = None\\n for key,val in kwargs.iteritems():\\n if key == 'path': str_path = val\\n if key == 'plugin': str_plugin = val\\n if key == 'tree_convertFrom': ft_convertFrom = val\\n if key == 'type_convertTo': str_convertTo = val\\n if key == 'SeriesFilesCount': SeriesFilesCount = val\\n\\n s = self.contents\\n\\n if s.cd(str_path)['status']:\\n s.mknode(['dataView', 'plugins'])\\n if str_plugin.lower() == 'pacspull':\\n dataTree = self.dataTree_PACSPull_build(\\n SeriesFilesCount = SeriesFilesCount\\n )\\n # print(dataTree)\\n if str_plugin.lower() == 'mri_convert':\\n if ft_convertFrom and len(str_convertTo):\\n dataTree = self.dataTree_mriConvert_build(\\n PACSPullTree = ft_convertFrom,\\n convertTo = str_convertTo\\n )\\n if str_plugin.lower() == 'recon-all':\\n dataTree = self.dataTree_reconall()\\n if str_plugin.lower() == 'tractography':\\n dataTree = self.dataTree_tractography()\\n s.cd('dataView')\\n s.graft(dataTree, '/files')\\n s.cd('/')\\n s.tree_metaData_print(False)\",\n \"def generate_api_docs(self):\\n if self.API_OUTPUT_DIR:\\n args = [\\n # Put documentation for each module on its own page\\n '-e',\\n # don't create the \\\"modules.rst\\\" file (the table of contents\\n # file) as this is already provided by the package's main rst\\n # file.\\n '-T',\\n # Overwrite existing files\\n '--force',\\n '-o', self.API_OUTPUT_DIR,\\n # the package to generate docs from\\n self.PROJECT_DIR\\n ]\\n excludes = [\\n os.path.join(self.PROJECT_DIR, p)\\n if not os.path.isabs(p) else p\\n for p in self.API_EXCLUDE_DIRS\\n ]\\n apidoc.main(args + excludes)\",\n \"def do_docs(self, path):\\n print(\\\"scaraping documentation\\\")\\n for p in path.glob(\\\"**/*\\\"):\\n if p.is_file():\\n parts = p.relative_to(path).parts\\n if parts[-1].endswith(\\\"rst\\\"):\\n data = tsparse(p.read_bytes())\\n blob = DocBlob()\\n blob.arbitrary = data\\n blob.content = {}\\n\\n blob.ordered_sections = []\\n blob.item_file = None\\n blob.item_line = None\\n blob.item_type = None\\n blob.aliases = []\\n blob.example_section_data = Section()\\n blob.see_also = []\\n blob.signature = None\\n blob.references = None\\n blob.refs = []\\n\\n self.docs[parts] = json.dumps(blob.to_json(), indent=2)\\n else:\\n pass\\n # data = p.read_bytes()\",\n \"def get_data(self):\\n\\n all_data = OrderedDict()\\n projects = [Path(proj) for proj in glob(str(self.data_path.joinpath(\\\"*\\\"))) if Path(proj).is_dir()]\\n\\n for project in projects:\\n files = []\\n \\n # Read all csv files and save them as a list in files\\n for ver in glob(str(project.joinpath(\\\"*.csv\\\"))):\\n files.extend(pd.read_csv(ver, usecols=['time', 'buggy']).values.tolist())\\n \\n # Create a pandas dataframe from the csv sorted by datetime\\n df = pd.DataFrame(files, columns=['Time', 'Bugs']).sort_values(by='Time').reset_index(drop=True)\\n \\n # Convert time to Pandas DateTime format\\n df['Time'] = pd.to_datetime(df['Time']) \\n \\n # Group bug counts by week starting on monday\\n df = df.reset_index().set_index('Time').groupby(\\n [pd.Grouper(freq='W-MON')])[\\\"Bugs\\\"].sum().astype(int).reset_index()\\n \\n df = df.set_index('Time')\\n # Save the data to dictionary\\n all_data.update(OrderedDict({project.name: df}))\\n\\n return all_data\",\n \"def submit_data(self):\\n\\n database = Database()\\n project_data = []\\n\\n project_entries = [\\\"\\\",\\n \\\"\\\",\\n \\\"\\\",\\n self.proj_date.get(),\\n self.proj_descrpt.get(),\\n self.proj_estdatest.get(),\\n self.proj_estdateend.get(),\\n self.proj_estbudget.get(),\\n self.proj_actdatest.get(),\\n self.proj_actdateend.get(),\\n self.proj_actcost.get()]\\n\\n index = 0\\n num_filled = 0\\n for item in project_entries:\\n if item == \\\"\\\":\\n project_entries[index] = None\\n else:\\n num_filled += 1\\n index += 1\\n\\n cus_name = self.customer_name.get()\\n\\n if num_filled == 0 and cus_name == \\\"\\\":\\n ErrorMessageWindow(\\\"You have to fill in at least one argument!\\\")\\n else:\\n # If a customer name is provided.\\n if cus_name != \\\"\\\":\\n customer_data = database.query_customer(cus_name=cus_name)\\n if customer_data:\\n project_entries[1] = customer_data[0][0]\\n project_data = self.multi_project(database.query_project(\\n project_query_options=project_entries))\\n else:\\n ErrorMessageWindow(\\\"No customer with this name found.\\\")\\n else:\\n project_data = self.multi_project(database.query_project(\\n project_query_options=project_entries))\\n\\n if project_data:\\n schedule_data = database.query_project_tasks(\\n project_data=project_data)\\n customer_data = database.query_customer(project_data[0][1])\\n\\n region_data = database.query_region(\\n region_id=customer_data[0][1])\\n\\n # Project schedule window definition.\\n ps_window = tkinter.Tk()\\n ps_window.wm_title(\\\"Project Schedule Display\\\")\\n tkinter.Label(\\n ps_window, text=\\\"Project Information:\\\"\\n ).grid()\\n\\n # Display project information.\\n tkinter.Label(\\n ps_window,\\n text=\\\"Project ID: {}\\\".format(project_data[0][0]),\\n ).grid(\\n pady=5, column=0, row=1\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Description: {}\\\".format(project_data[0][4]),\\n ).grid(\\n pady=5, column=1, row=1\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Company: {}\\\".format(customer_data[0][2]),\\n ).grid(\\n pady=5, column=0, row=2\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Contract Date: {}\\\".format(project_data[0][3]),\\n ).grid(\\n pady=5, column=1, row=2\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Region: {}\\\".format(region_data[0][1]),\\n ).grid(\\n pady=5, column=2, row=2\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Start Date: {}\\\".format(project_data[0][5]),\\n ).grid(\\n pady=5, column=0, row=3\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"End Date: {}\\\".format(project_data[0][6]),\\n ).grid(\\n pady=5, column=1, row=3\\n )\\n tkinter.Label(\\n ps_window,\\n text=\\\"Budget: ${}\\\".format(project_data[0][7]),\\n ).grid(\\n pady=5, column=2, row=3\\n )\\n\\n # Schedule table definition.\\n p_s_view = tkinter.ttk.Treeview(ps_window)\\n p_s_view.grid(pady=10, column=1, row=5)\\n\\n p_s_view[\\\"show\\\"] = \\\"headings\\\"\\n p_s_view[\\\"columns\\\"] = (\\n \\\"Start Date\\\", \\\"End Date\\\", \\\"Task Description\\\",\\n \\\"Skill(s) Required\\\", \\\"Quantity Required\\\"\\n )\\n\\n # Table column headings.\\n for heading in p_s_view[\\\"columns\\\"]:\\n p_s_view.heading(heading, text=heading)\\n p_s_view.column(heading, width=250)\\n\\n # Load data into table.\\n for item in schedule_data:\\n p_s_view.insert('', 'end', values=item)\\n else:\\n ErrorMessageWindow(\\\"No project found with given info.\\\")\",\n \"def build(config):\",\n \"def pre_build_project(project_data):\\n ListenerManager.call(_project_pre_build_manager, project_data)\",\n \"def contents_build_1(self, **kwargs):\\n\\n SeriesFilesCount = 10\\n for key,val in kwargs.iteritems():\\n if key == 'SeriesFilesCount': SeriesFilesCount = val\\n\\n # First, build a PACS_pull tree\\n self.dataComponent_build(\\n path = '/',\\n plugin = 'PACSPull',\\n SeriesFilesCount = SeriesFilesCount\\n )\\n\\n self.dataComponent_pluginBuild(\\n path = '/plugins'\\n )\\n\\n\\n # Now \\\"run\\\" an mri_convert to nifi\\n # self.dataComponent_pluginRun(\\n # inputPath = '/dataView/files',\\n # outputPath = '/plugin/run',\\n # plugin = 'mri_convert'\\n # )\",\n \"def post_build_project(project_data):\\n ListenerManager.call(_project_post_build_manager, project_data)\",\n \"def _build_datasets(self):\\n self._build_datasets_sis3302()\\n self._build_datasets_sis3305()\",\n \"def build(opt):\\n version = '1.1'\\n dpath = os.path.join(opt['datapath'], 'ner')\\n\\n # check if data had been previously built\\n raw_path = os.path.abspath(opt['raw_dataset_path'] or \\\".\\\")\\n if len([f for f in os.listdir(raw_path) if f.endswith(\\\".iob\\\")]) == 0:\\n if not build_data.built(dpath, version_string=version):\\n print('[target data path: ' + dpath + ']')\\n # make a clean directory if needed\\n if build_data.built(dpath):\\n # an older version exists, so remove these outdated files.\\n build_data.remove_dir(dpath)\\n build_data.make_dir(dpath)\\n\\n ds_path = os.environ.get('DATASETS_URL')\\n file_name = 'gareev.tar.gz'\\n if not ds_path:\\n raise RuntimeError(\\\"Looks like the `DATASETS_URL` variable is set incorrectly\\\")\\n print('Trying to download a dataset %s from the repository' % file_name)\\n url = urllib.parse.urljoin(ds_path, file_name)\\n build_data.download(url, dpath, file_name)\\n build_data.untar(dpath, file_name)\\n print('Downloaded a %s dataset' % file_name)\\n # mark the data as built\\n build_data.mark_done(dpath, version_string=version)\\n opt['raw_dataset_path']=dpath\\n create_heap_file(opt['raw_dataset_path'])\\n else:\\n print('Use raw data for {}'.format(opt['raw_dataset_path']))\\n create_heap_file(dpath, opt['raw_dataset_path'])\\n build_data.mark_done(dpath, version_string=version)\\n print(\\\"Use dataset from path: %s\\\" % repr(opt['raw_dataset_path']))\",\n \"def open_doc(self, widget, data=None):\\n\\t\\twebbrowser.open('file://'+os.path.abspath(\\\"./doc/build/html/index.html\\\"))\",\n \"def gen_project(project_name, project_revision, target, template, working_dir):\\n gen_project_tcl(project_name, project_revision,\\n target, template, working_dir)\\n qsys_files = filter(lambda file: file.endswith(\\\".qsys\\\"), target.files_list)\\n for file in qsys_files:\\n gen_qsys_system_from_qsys_file(file, working_dir)\\n\\n log_msg = \\\"Generating project\\\"\\n cmd = f\\\"cd {working_dir} && {QUARTUS_BIN_DIR}quartus_sh -t make_project.tcl\\\"\\n log_file_path = working_dir + \\\"project_gen.log\\\"\\n\\n run_cmd_and_log(cmd, log_msg, log_file_path)\",\n \"def docs():\",\n \"def create_project_info(data):\\n\\t\\n\\tproject = ProjectInfo()\\n\\tproject.name = data['name']\\n\\tproject.description = data['description']\\n\\tproject.start_date = data['start_date']\\n\\tproject.end_date = data['end_date']\\n\\tproject.save()\\n\\tprint ('Inserted')\\n\\treturn True\",\n \"def build(root):\",\n \"def get_projects_data():\\n wcscanner_path = context.__BASE_PATH__ + '/.wcscanner'\\n\\n data = []\\n for project in os.listdir(wcscanner_path):\\n if (os.path.isdir(os.path.join(wcscanner_path, project))):\\n update_project_data(project)\\n project_path = '{}/{}'.format(wcscanner_path, project)\\n f = open('{}/.project'.format(project_path), 'r')\\n data.append(json.load(f))\\n f.close()\\n return data\",\n \"def write_data_index(self):\\n content = \\\"\\\"\\n self.remove(os.path.join(config[\\\"data_subdir\\\"], \\\"*\\\"))\\n if self.data_index:\\n print(\\\"- writing data index\\\")\\n content += f\\\"# [{config['github_repo_name']}]({config['github_pages_url']})\\\\n\\\"\\n content += \\\"\\\\n## Index of Data files in this Repository\\\\n\\\"\\n for data, links in sorted(self.data_index.items(), key=lambda x: natsort(x[0])):\\n if links:\\n content += f\\\"\\\\n### {data}\\\\n\\\"\\n content += f\\\"\\\\n\\\"\\n for link in links:\\n content += f\\\"* {link}\\\\n\\\"\\n data_src = os.path.join(self.src_dir, config[\\\"data_subdir\\\"], data)\\n data_dst = os.path.join(self.dst_dir, config[\\\"data_subdir\\\"], data)\\n print(f\\\"- copying {data_src} to {data_dst}\\\")\\n shutil.copy(data_src, data_dst)\\n self.write_md2html(\\\"data_index\\\", content)\",\n \"def buildPage(self):\\n Users = [(u['name']) for u in driver.nodes.match(\\\"User\\\")]\\n Tissues = [(t['name']) for t in driver.nodes.match(\\\"Tissue\\\")]\\n Diseases = [(d['name']) for d in driver.nodes.match(\\\"Disease\\\")]\\n self.add_basic_layout()\\n layout = [html.Div([\\n html.Div([html.H4('Project information', style={'width': '15.5%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.H4('', id='update_project_id', style={'width': '15%', 'verticalAlign': 'top', 'display': 'none'}),\\n html.Br(),\\n html.Div(children=[html.Label('Project name:*', style={'marginTop': 15}),\\n dcc.Input(id='project name', placeholder='Insert name...', type='text', style={'width': '100%', 'height': '35px'})],\\n style={'width': '100%'}),\\n html.Br(),\\n html.Div(children=[html.Label('Project Acronym:', style={'marginTop': 15}),\\n dcc.Input(id='project acronym', placeholder='Insert name...', type='text', style={'width': '100%', 'height': '35px'})],\\n style={'width': '100%'}),\\n html.Br(),\\n html.Div(children=[html.Label('Project Responsible:*', style={'marginTop': 15})],\\n style={'width': '49%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[html.Label('Project Participants:*', style={'marginTop': 15})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Dropdown(id='responsible-picker', options=[{'label': i, 'value': i} for i in Users], value=[], multi=True, searchable=True, style={'width': '100%'})],\\n style={'width': '49%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Dropdown(id='participant-picker', options=[{'label': i, 'value': i} for i in Users], value=[], multi=True, searchable=True, style={'width': '100%'})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Br(),\\n html.Br(),\\n html.Div(children=[html.Label('Project Data Types:*', style={'marginTop': 10})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[html.Label('Project Disease:*', style={'marginTop': 10})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Dropdown(id='data-types-picker', options=[{'label': i, 'value': i} for i in DataTypes], value=[], multi=True, searchable=True, style={'width': '100%'})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Dropdown(id='disease-picker', options=[{'label': i, 'value': i} for i in Diseases], value=[], multi=True, searchable=True, style={'width': '100%'})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Br(),\\n html.Br(),\\n html.Div(children=[html.Label('Project Tissue:*', style={'marginTop': 10})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[html.Label('Project Intervention:', style={'marginTop': 10})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Dropdown(id='tissue-picker', options=[{'label': i, 'value': i} for i in Tissues], value=[], multi=True, searchable=True, style={'width': '100%'})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Input(id='intervention-picker', placeholder='E.g. SNOMED identifier|SNOMED identifier|...', type='text', style={'width': '100%', 'height': '54px'})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Br(),\\n html.Br(),\\n html.Div(children=[html.Label('Number of subjects:*', style={'marginTop': 15})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[html.Label('Timepoints:', style={'marginTop': 15})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Input(id='number_subjects', placeholder='E.g. 77 (each unique patient counts as 1 subject)', type='text', style={'width': '100%', 'height': '35px'})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Div(children=[dcc.Input(id='number_timepoints', placeholder='E.g. 2 months|15 days|24 hours...', type='text', style={'width': '100%', 'height': '35px'})],\\n style={'width': '49%', 'marginLeft': '2%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Br(),\\n html.Br(),\\n html.Div(children=[html.Label('Follows up project:', style={'marginTop': 15}),\\n dcc.Input(id='related_to', placeholder='Use the Project Identifier (P000000X)', type='text', style={'width': '100%', 'height': '35px'})],\\n style={'width': '49%', 'marginLeft': '0%', 'verticalAlign': 'top', 'display': 'inline-block'}),\\n html.Br(),\\n html.Br(),\\n html.Div(children=[html.Label('Project Description:', style={'marginTop': 15}),\\n dcc.Textarea(id='project description', placeholder='Enter description...', style={'width': '100%', 'height': '100px'})]),\\n html.Br(),\\n html.Div(children=[html.Label('Starting Date:', style={'marginTop': 10}),\\n dcc.DatePickerSingle(id='date-picker-start', placeholder='Select date...', clearable=True)],\\n style={'width': '30%', 'verticalAlign': 'top', 'marginTop': 10, 'display': 'inline-block'}),\\n html.Div(children=[html.Label('Ending Date:', style={'marginTop': 10}),\\n dcc.DatePickerSingle(id='date-picker-end', placeholder='Select date...', clearable=True)],\\n style={'width': '30%', 'verticalAlign': 'top', 'marginTop': 10, 'display': 'inline-block'}),\\n html.Div(children=html.Button('Create Project', id='project_button', n_clicks=0, className=\\\"button_link\\\",\\n style={'fontSize': '25px'}), style={'width': '100%', 'padding-left': '87%', 'padding-right': '0%'}),\\n html.Br(),\\n html.Div(children=[html.A(children=html.Button('Download Clinical Data template', id='download_button', n_clicks=0,\\n style={'fontSize': '16px', 'display': 'block'}),\\n id='download_link', href='', n_clicks=0)], style={'width': '100%', 'padding-left': '87%', 'padding-right': '0%'}),\\n html.Br(),\\n html.Div(id='project-creation', style={'fontSize': '20px', 'marginLeft': '70%'}),\\n html.Br()]),\\n html.Hr()])]\\n\\n self.extend_layout(layout)\",\n \"def _make_data(self):\\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)\",\n \"def index():\\n with open(\\\"PROJECT.md\\\", \\\"r\\\") as project_file:\\n md_template_string = markdown.markdown(\\n project_file.read(), extensions=[\\\"fenced_code\\\"]\\n )\\n return md_template_string\",\n \"def build(self, data: dict) -> GenerativeDesignExecution:\\n execution = GenerativeDesignExecution.build(data)\\n execution._session = self.session\\n execution.project_id = self.project_id\\n return execution\",\n \"def buildHTML(self):\\n\\n # TODO: make this configurable via a dialog\\n os.chdir(self.file_path.parent)\\n proc = subprocess.Popen(\\n [\\\"make\\\", \\\"clean\\\"],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT\\n )\\n for line in proc.stdout:\\n print(\\\"stdout: \\\" + str(line.rstrip(), encoding='utf8'))\\n print('----------------')\\n proc = subprocess.Popen(\\n [\\\"make\\\", \\\"html\\\"],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT\\n )\\n proc.wait()\\n for line in proc.stdout:\\n print(\\\"stdout: \\\" + str(line.rstrip(), encoding='utf8'))\\n\\n # Load corresponding HTML file from newly-built Sphinx docs\\n self.preview.load_html(self.output_html_path)\",\n \"def qck_gen_proj(self, master):\\r\\n if not self._check_project_name():\\r\\n return\\r\\n\\r\\n # Clear out driver list and board\\r\\n self.newProj.board = ()\\r\\n self.newProj.drvList = []\\r\\n\\r\\n # Configure ksdkProj given GUI state\\r\\n self.localSDK.get_version()\\r\\n self.newProj.name = self.widgetList[4].get()\\r\\n self.newProj.setKsdkPath(self.localSDK.path)\\r\\n self.newProj.sdkVer = self.localSDK.version\\r\\n self.newProj.useBSP = not self.localSDK.isNewVersion()\\r\\n\\r\\n # Add the board\\r\\n try:\\r\\n userBoard = int(self.widgetList[6].curselection()[0]) + 1\\r\\n self.newProj.add_board(userBoard, self.localSDK.brdList)\\r\\n except IndexError:\\r\\n tkMessageBox.showinfo(\\\"No board selected!\\\",\\\\\\r\\n \\\"Make sure a board has been selected.\\\")\\r\\n return\\r\\n\\r\\n self.widgetList[10].step(30)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n # Quick check to see if this poject already exists\\r\\n checkPath = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/' + self.newProj.name\\r\\n if os.path.isdir(checkPath):\\r\\n tkMessageBox.showinfo(\\\"Project exists\\\",\\\\\\r\\n \\\"A project by this name already exists.\\\")\\r\\n return\\r\\n\\r\\n # in quick mode there is always generated the board project\\r\\n self.newProj.isBoardProject = True\\r\\n \\r\\n # Add all drivers for this device\\r\\n self.localSDK.get_drivers()\\r\\n maskRet = kT.mask_features(kTool.KsdkTools(), self.newProj.sdkPath, self.newProj.sdkVer, \\\\\\r\\n self.localSDK.drvList, self.newProj.device[1], self.newProj.device[2])\\r\\n self.newProj.portCount = maskRet[0]\\r\\n self.newProj.dmaCount = maskRet[1]\\r\\n self.newProj.tsiVersion = maskRet[2]\\r\\n self.newProj.add_all_drv(self.localSDK.drvList)\\r\\n\\r\\n kT.debug_log('Port Count: ' + str(self.newProj.portCount))\\r\\n\\r\\n #Generate IAR project files\\r\\n #self.newProj.fast_build_IAR()\\r\\n self.newProj.workSpace = self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath(self.newProj.board[1]) + '/'\\r\\n projectPath = self.newProj.workSpace + self.newProj.name\\r\\n\\r\\n #Get all include paths lists into one list\\r\\n includeList = []\\r\\n index = 0\\r\\n isPresent = False\\r\\n while index < len(self.newProj.drvList):\\r\\n count = 0\\r\\n while count < len(self.newProj.drvList[index][2]):\\r\\n isPresent = False\\r\\n newPath = str(\\\\\\r\\n self.newProj.drvList[index][2][count]\\\\\\r\\n )\\r\\n if len(includeList) > 0:\\r\\n listIndex = 0\\r\\n while listIndex < len(includeList):\\r\\n if newPath == includeList[int(listIndex) - 1]:\\r\\n isPresent = True\\r\\n listIndex += 1\\r\\n if not isPresent:\\r\\n includeList.append(newPath)\\r\\n count += 1\\r\\n index += 1\\r\\n\\r\\n self.newProj.libList.append('platform')\\r\\n if not os.path.isdir(projectPath):\\r\\n os.makedirs(projectPath)\\r\\n self.newProj.rtos = 'bm'\\r\\n\\r\\n if not os.path.isfile(projectPath + '/main.c'):\\r\\n self.newProj.make_main_file(projectPath, includeList)\\r\\n if not os.path.isfile(projectPath + '/hardware_init.c'):\\r\\n self.newProj.make_hw_file(projectPath)\\r\\n\\r\\n self.widgetList[10].step(30)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n ## Copy over BSP files\\r\\n if self.newProj.useBSP:\\r\\n if not os.path.isdir(projectPath + '/board'):\\r\\n os.mkdir(projectPath + '/board')\\r\\n bspDir = self.newProj.sdkPath + '/examples/' + self.newProj.board[1]\\r\\n bspList = kT.list_files(bspDir)\\r\\n for f in bspList:\\r\\n if f[-2:] == '.c':\\r\\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\\r\\n if f[-2:] == '.h':\\r\\n shutil.copyfile(bspDir + '/' + f, projectPath + '/board/' + f)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.IARname, self.newProj.device):\\r\\n print self.newProj.isLinked\\r\\n if self.localSDK.isNewVersion():\\r\\n newIar = kIarNew.KsdkIarNew(self.newProj)\\r\\n else:\\r\\n newIar = kIar.KsdkIar(self.newProj)\\r\\n newIar.gen_ewp(self.newProj)\\r\\n newIar.gen_eww(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KeilMDK, self.newProj.device):\\r\\n #Generate MDK project files\\r\\n if self.localSDK.isNewVersion():\\r\\n newMdk = kMdkNew.KsdkMdkNew(self.newProj)\\r\\n else:\\r\\n newMdk = kMdk.KsdkMdk(self.newProj)\\r\\n newMdk.gen_proj(self.newProj)\\r\\n newMdk.gen_wkspace(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.KinetisDesignStudio, self.newProj.device):\\r\\n #Generate KDS project fiels\\r\\n print self.newProj.isLinked\\r\\n if self.localSDK.isNewVersion():\\r\\n newKds = kKdsNew.KsdkKdsNew(self.newProj)\\r\\n else:\\r\\n newKds = kKds.KsdkKds(self.newProj)\\r\\n\\r\\n newKds.gen_cproject(self.newProj)\\r\\n newKds.gen_project(self.newProj)\\r\\n newKds.gen_working_set(self.newProj)\\r\\n newKds.gen_debug(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.AtollicStudio, self.newProj.device):\\r\\n #Generate ATL project files\\r\\n if self.localSDK.isNewVersion():\\r\\n newAtl = kAtlNew.KsdkAtlNew(self.newProj)\\r\\n else:\\r\\n newAtl = kAtl.KsdkAtl(self.newProj)\\r\\n newAtl.gen_cproject(self.newProj)\\r\\n newAtl.gen_project(self.newProj)\\r\\n newAtl.gen_debug(self.newProj)\\r\\n newAtl.gen_settings(self.newProj)\\r\\n\\r\\n if self.localSDK.isToolchainTypeSupported(kSdk.ToolchainType.ARMgcc):\\r\\n #Generate GCC project files\\r\\n if not self.newProj.fast_build_GCC():\\r\\n tkMessageBox.showinfo(\\\"Missing CMake Files\\\",\\\\\\r\\n \\\"CMake files are missing from your KSDK installation.\\\")\\r\\n\\r\\n #Text for window\\r\\n genString = 'Your project was created in the following location:\\\\n'\\r\\n pathString = ''\\r\\n pathString += self.newProj.sdkPath + '/' + self.newProj.parent.getDirectoryStructureHelper().getUserLinkedExamplesPath( self.newProj.board[1]) + '/' + self.newProj.name + '/'\\r\\n genString += pathString\\r\\n genString += '\\\\nPress the button below to open project location folder.'\\r\\n\\r\\n #Create window to show USER that project has been generated and where it is.\\r\\n popGen = Toplevel()\\r\\n if self.newProj.osType == 'Windows':\\r\\n winH = 100 * WIN_SCALE\\r\\n winW = 600 * WIN_SCALE\\r\\n elif self.newProj.osType == 'Darwin':\\r\\n if platform.mac_ver()[0][:5] == '10.10':\\r\\n winH = 100\\r\\n winW = 600\\r\\n elif platform.mac_ver()[0][:5] == '10.11':\\r\\n winH = 100\\r\\n winW = 660\\r\\n else:\\r\\n winH = 100\\r\\n winW = 600\\r\\n popGen.config(height=winH, width=winW)\\r\\n popGen.grid()\\r\\n if self.newProj.osType == 'Linux':\\r\\n img = Image(\\\"photo\\\", data=kImg.boardImages['kds_icon.gif']) # Use the .gif in Linux\\r\\n popGen.tk.call('wm', 'iconphoto', popGen._w, img)\\r\\n popGen.title(\\\"Project created\\\")\\r\\n popGen.geometry('%dx%d+%d+%d' % (winW, winH, master.winfo_x() + 20, master.winfo_y() + 20))\\r\\n popGen.resizable(width=FALSE, height=FALSE)\\r\\n popGen.configure(background='#E7E7E7')\\r\\n\\r\\n genTxt = Label(popGen, text=genString, justify=LEFT)\\r\\n genTxt.grid(row=0, column=0, columnspan=2, padx=5, pady=5)\\r\\n\\r\\n #Create button to open project folder\\r\\n ## IF we are in windows, we need to replace all '/' with '\\\\\\\\'\\r\\n tempString = pathString[:]\\r\\n if self.newProj.osType == 'Windows':\\r\\n pathString = ''\\r\\n pathString = kT.string_replace(tempString, '/', '\\\\\\\\')\\r\\n\\r\\n genButton = Button(popGen, text='Open Project Folder', command=lambda: self.view_project(pathString, popGen))\\r\\n genButton.grid(row=2, column=0, sticky=W, padx=5, pady=5)\\r\\n\\r\\n self.widgetList[10].step(35)\\r\\n self.widgetList[10].update_idletasks()\\r\\n\\r\\n # patch to implement automation test\\r\\n self.pop_gen = popGen\\r\\n\\r\\n return\",\n \"def generate_page_sections_dict(self, project_page_data: dict):\\n wiki_obj = WikiService()\\n\\n short_description = (\\n f\\\"\\\\n{project_page_data['project']['shortDescription']}\\\\n\\\"\\n )\\n\\n created_date = wiki_obj.format_date_text(\\n project_page_data['project']['created']\\n )\\n # created_date_text = f\\\"\\\\n{created_date}\\\\n\\\" \\n # due_date = wiki_obj.format_date_text(\\n # project_page_data['project']['due_date']\\n # )\\n timeframe = (\\n f\\\"\\\\n* '''Start Date:''' {created_date}\\\\n\\\"\\n # f\\\"\\\\n* '''End Date:''' Estimate {due_date}\\\\n\\\"\\n )\\n\\n\\n project_url = (\\n f\\\"\\\\n{project_page_data['project']['url']}\\\\n\\\"\\n )\\n\\n hashtag = (\\n project_page_data['project']['changesetComment']\\n )\\n hashtag = (\\n project_page_data['project']['changesetComment'].replace(\\n \\\"#\\\", \\\"<nowiki>#</nowiki>\\\"\\n )\\n )\\n hashtag_text = (\\n f\\\"\\\\n{hashtag}\\\\n\\\"\\n )\\n\\n instructions_text = (\\n project_page_data['project']\\n ['externalSource']\\n ['instructions']\\n )\\n instructions = (\\n f\\\"\\\\n{instructions_text}\\\\n\\\"\\n )\\n\\n per_task_instructions_text = (\\n project_page_data['project']\\n ['externalSource']\\n ['perTaskInstructions']\\n )\\n per_task_instructions = (\\n f\\\"\\\\n{per_task_instructions_text}\\\\n\\\"\\n )\\n\\n imagery_text = (\\n project_page_data['project']\\n ['externalSource']\\n ['imagery']\\n )\\n imagery = (\\n f\\\"\\\\n{imagery_text}\\\\n\\\"\\n )\\n\\n license_text = (\\n project_page_data['project']\\n ['externalSource']\\n ['license']\\n )\\n license = (\\n f\\\"\\\\n{license_text}\\\\n\\\"\\n )\\n\\n # metrics = (\\n # f\\\"\\\\n* {project_page_data.instructions}\\\\n\\\"\\n # )\\n # quality_assurance = (\\n # f\\\"\\\\n* {project_page_data.quality_assurance}\\\\n\\\"\\n # )\\n\\n users = project_page_data['project'][\\\"users\\\"]\\n project_users = \\\"\\\"\\n for user in users:\\n project_users += (\\n f\\\"\\\\n| {user['userId']}\\\\n| {user['userName']}\\\\n|-\\\"\\n )\\n\\n \\n\\n project_page_sections = {\\n self.short_description_section: short_description,\\n self.timeframe_section: timeframe,\\n # self.timeframe_section: {\\n # self.created_section: created_date_text\\n # }, # if choose use subsection for timeframe \\n self.url_section: project_url,\\n self.external_sources_section: {\\n self.instructions_section: instructions,\\n self.per_task_instructions_section: per_task_instructions,\\n self.imagery_section: imagery,\\n self.license_section: license\\n },\\n self.hashtag_section: hashtag_text,\\n # self.instructions_section: instructions,\\n # self.metrics_section: metrics,\\n # self.quality_assurance_section: quality_assurance,\\n self.team_user_section: {\\n self.users_list_section: project_users\\n }\\n }\\n return project_page_sections\",\n \"def update_build_commit_documents(self, build_data):\\n\\n product, version, prev_build_num = (\\n build_data[key] for key\\n in ['product', 'version', 'prev_build_num']\\n )\\n prev_build_data = self.db.get_document(\\n f'{product}-{version}-{prev_build_num}'\\n )\\n\\n for project, shas in build_data['manifest'].items():\\n new_shas = [sha.replace(f'{project}-', '').encode('utf-8')\\n for sha in shas]\\n old_shas = [sha.replace(f'{project}-', '').encode('utf-8')\\n for sha in prev_build_data['manifest'].get(\\n project, []\\n )]\\n\\n diff_walker = cbutil_git.DiffWalker(self.repo_base_path / project)\\n diff_commits = diff_walker.walk(old_shas, new_shas)\\n\\n if not diff_commits:\\n continue\\n\\n if old_shas:\\n commit_ids = [f'{project}-{commit.id.decode()}'\\n for commit in diff_commits]\\n else:\\n # Only keep most recent commit for new projects\\n commit_ids = [f'{project}-{diff_commits[0].id.decode()}']\\n\\n build_name = build_data['key_']\\n logging.debug(f'Updating {build_name} build document for '\\n f'the following commits: {\\\", \\\".join(commit_ids)}')\\n build_document = self.db.get_document(build_name)\\n build_document['commits'].extend(commit_ids)\\n self.db.upsert_documents({build_name: build_document})\\n\\n for commit_id in commit_ids:\\n commit_document = self.db.get_document(commit_id)\\n\\n # The check protects from duplicate build document IDs\\n # for a commit (potentially due to a loading failure)\\n if build_name not in commit_document['in_build']:\\n commit_document['in_build'].append(build_name)\\n\\n self.db.upsert_documents({commit_id: commit_document})\",\n \"def load_project_udfs(ref_db):\\n udfs = prepare_udf_source_info('Project', lims.get_projects())\\n project = ref_db.get('project')\\n project_details = ref_db.get('project-details')\\n for udf, udf_field in udfs.items():\\n if 'discontinued' not in udf.split('_'):\\n if udf in PROJ_UDF_EXCEPTIONS:\\n key = 'project-'+udf\\n project[udf] = key\\n inf=save_couchdb_ref_obj(ref_db, project)\\n else:\\n key = 'project-details-'+udf\\n project_details[udf] = key\\n inf=save_couchdb_ref_obj(ref_db, project_details)\\n udf_field['_id'] = key\\n inf=save_couchdb_ref_obj(ref_db, udf_field)\",\n \"def test_main(self):\\n self.createFakeSphinxProject()\\n self.builder.main([self.sphinxDir.parent().path])\\n self.verifyBuilt()\",\n \"def update_project_data(project_name):\\n project_path = context.__PROJECTS_PATH__+ '/' + project_name\\n f = open(project_path+'/.project', 'r')\\n project_data = json.load(f)\\n f.close()\\n\\n image_count = len(os.listdir(project_path)) - 2\\n\\n if image_count > 0:\\n\\n img = Image.open('{}/{}.jpg'.format(project_path, image_count-1))\\n img = img.resize((640,480))\\n buffered = BytesIO()\\n img.save(buffered, format=\\\"JPEG\\\")\\n img_str = base64.b64encode(buffered.getvalue()).decode('ascii')\\n\\n project_data['preview_data'] = img_str\\n project_data['size'] = round(int(subprocess.check_output(['du', project_path, '-k']).split()[0]) / 1000,2)\\n\\n with open('{}/.project'.format(project_path), 'w') as config_file:\\n json.dump(project_data, config_file, indent=4)\\n config_file.close()\",\n \"def generate():\\n local('cd doc && make clean && make html')\",\n \"def docs(session):\\n session.install('-rrequirements-dev.txt')\\n session.install('-e', '.')\\n run_sphinx(session)\",\n \"def build_data(path):\\n slab_logger.log(15, 'Building ccs-dev-1 site in ccs-data')\\n if not os.path.isdir(os.path.join(path, 'services', 'ccs-data')):\\n return(1, 'Could not find ccs-data repo. Pleas try \\\"stack workon ccs-data\\\"')\\n if yaml_utils.decrypt_set(path) != 0:\\n return(1, \\\"unable to decrypt the pulp password\\\")\\n\\n data_reponame = \\\"ccs-data\\\"\\n slab_logger.debug(\\\"Building the data.\\\")\\n returncode, myinfo = run_this(\\n './lightfuse.rb -c hiera-bom-unenc.yaml --site ccs-dev-1 && cd ..',\\n cwd=os.path.join(path, \\\"services\\\", data_reponame))\\n if returncode == 0:\\n try:\\n # src, dest\\n shutil.copyfile(os.path.join(path,\\n 'services',\\n data_reponame,\\n 'out',\\n 'ccs-dev-1',\\n 'dev-tenant',\\n 'etc',\\n 'ccs',\\n 'data',\\n 'hosts'),\\n os.path.join(path,\\n 'hosts'))\\n except IOError as err:\\n return(1, err)\\n return(returncode, myinfo)\",\n \"def build(self, data: dict) -> GemTable:\\n table = GemTable.build(data)\\n table.project_id = self.project_id\\n table.session = self.session\\n return table\",\n \"def docs(command, warn_is_error=False, options=\\\"\\\"):\\n print(\\n \\\"\\\"\\\"\\nRunning Sphinx to test the docs building\\n========================================\\n\\\"\\\"\\\"\\n )\\n o = \\\"-W \\\" if warn_is_error else \\\"\\\"\\n if \\\"-W\\\" in options:\\n options = options.replace(\\\"-W\\\", \\\"\\\")\\n options = options + \\\" \\\" + o\\n shutil.rmtree(\\\"docs/_build\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/api\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/code_reference/api\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/jupyter_execute\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/examples/default_config.yaml\\\", ignore_errors=True)\\n command.run(\\\"python -m boa.config --output-path docs/examples/default_config.yaml\\\", echo=True, pty=POSIX)\\n command.run(f\\\"sphinx-build {options} -b html docs docs/_build\\\", echo=True, pty=POSIX)\",\n \"def build_data(self):\\n from desiutil.io import combine_dicts\\n # Loop on exposures\\n odict = {}\\n for qanight in self.qa_nights:\\n for qaexp in qanight.qa_exps:\\n # Get the exposure dict\\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\\n odict = combine_dicts(odict, idict)\\n # Finish\\n self.data = odict\",\n \"def build(self, datas):\\n\\t\\t# Browse the list of files\\n\\t\\tfor data in datas:\\n\\t\\t\\tif isString(data):\\n\\t\\t\\t\\tdata = Data(data)\\n\\t\\t\\telif isList(data):\\n\\t\\t\\t\\tstate = None\\n\\t\\t\\t\\tname = \\\"\\\"\\n\\t\\t\\t\\tif len(data) >= 1:\\n\\t\\t\\t\\t\\tname = data[0]\\n\\t\\t\\t\\tif len(data) >= 2:\\n\\t\\t\\t\\t\\tstate = data[1]\\n\\t\\t\\t\\tdata = Data(name, state)\\n\\t\\t\\t# Cut the path of the file folder and piece\\n\\t\\t\\tself.addNode(self.tree,data.path(),data)\",\n \"def beehive_make_doc(self):\\n run_data = {\\n u'tags':[u'doc'],\\n u'local_package_path':self.local_package_path\\n } \\n self.ansible_playbook(u'docs', run_data, \\n playbook=self.beehive_doc_playbook)\",\n \"def Write(self):\\n template_mappings = {\\n 'pypi_token': self._project_definition.pypi_token or ''}\\n\\n file_content = []\\n\\n template_data = self._GenerateFromTemplate('environment', template_mappings)\\n file_content.append(template_data)\\n\\n if self._project_definition.name not in self._PROJECTS_WITHOUT_BUILD:\\n if self._project_definition.pypi_token:\\n template_data = self._GenerateFromTemplate(\\n 'pypi_token', template_mappings)\\n file_content.append(template_data)\\n\\n template_data = self._GenerateFromTemplate('matrix', template_mappings)\\n file_content.append(template_data)\\n\\n template_data = self._GenerateFromTemplate('install', template_mappings)\\n file_content.append(template_data)\\n\\n if self._project_definition.name != 'l2tdevtools':\\n template_data = self._GenerateFromTemplate(\\n 'install_l2tdevtools', template_mappings)\\n file_content.append(template_data)\\n\\n if self._project_definition.name in self._PROJECTS_WITHOUT_BUILD:\\n template_filename = 'build_off'\\n else:\\n template_filename = 'build'\\n\\n template_data = self._GenerateFromTemplate(\\n template_filename, template_mappings)\\n file_content.append(template_data)\\n\\n template_data = self._GenerateFromTemplate('test_script', template_mappings)\\n file_content.append(template_data)\\n\\n if self._project_definition.name not in self._PROJECTS_WITHOUT_BUILD:\\n template_data = self._GenerateFromTemplate('artifacts', template_mappings)\\n file_content.append(template_data)\\n\\n if self._project_definition.pypi_token:\\n template_data = self._GenerateFromTemplate(\\n 'deploy_script', template_mappings)\\n file_content.append(template_data)\\n\\n file_content = ''.join(file_content)\\n\\n with io.open(self.PATH, 'w', encoding='utf-8') as file_object:\\n file_object.write(file_content)\",\n \"def _builder_inited(app: sphinx.application.Sphinx) -> None:\\n _write_member_documentation_pages(\\n _create_documenter(env=app.env,\\n documenter_cls=sphinx.ext.autodoc.ModuleDocumenter,\\n name='tensorstore'))\",\n \"def collect_docs() -> Dict[str, Any]:\\n docs = {}\\n\\n for integration_dir, meta in all_integrations():\\n integration_name = integration_dir.name\\n markdown = \\\"\\\"\\n for readme in sorted(integration_dir.glob(\\\"*.md\\\")) + sorted(integration_dir.glob(\\\"README.md.jinja\\\")):\\n markdown += readme.read_text(encoding=\\\"utf-8\\\")\\n\\n if not markdown:\\n continue\\n\\n docs[integration_name] = {\\n \\\"markdown\\\": process_markdown_for_app(markdown, integration_dir, uses_legacy_build(meta))\\n }\\n\\n return docs\",\n \"def build(self, data: dict):\",\n \"def _createDataFromProject(self):\\n project_dict = self._project.asDict()\\n data_blocks = {}\\n headers_blocks = {}\\n for experiment_id, experiment_dict in project_dict['experiments'].items():\\n data = []\\n headers = []\\n for data_id, data_list in experiment_dict['calculated'].items():\\n headers.append(data_id)\\n data.append(data_list)\\n headers_blocks[experiment_id] = headers\\n data_transposed = [*zip(*data)]\\n data_blocks[experiment_id] = data_transposed\\n return headers_blocks, data_blocks\",\n \"def build_pages(ctx, show=False):\\n\\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\\n import pages\\n import webbrowser\\n\\n # Update all readmes first\\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\\n for line in lines:\\n print(subprocess.getoutput(['invoke', line]))\\n\\n pages.build(True, False)\\n if show:\\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))\",\n \"def docs(self):\\n self._doc_info = DocumentationURL()\\n self._doc_info.show()\",\n \"def __init__(self, project):\\n super(ReadTheDocsHelper, self).__init__()\\n self._project = project\\n self._url_lib_helper = url_lib.URLLibHelper()\",\n \"def task_mkdocs():\\n return Task(\\n file_dep=[MKDOCS],\\n actions=[\\n (needs, [\\\"jupyter_book\\\"]),\\n ],\\n uptodate=[not MKDOCS.exists()],\\n )\",\n \"def with_docs(self):\\r\\n self._configurations.append('javadoc')\\r\\n return self\",\n \"def build_project_dir(self, instance, private_data_dir):\\n project_dir = os.path.join(private_data_dir, 'project')\\n if not os.path.exists(project_dir):\\n os.mkdir(project_dir)\",\n \"def create_pdf(self):\\n\\n my_datetime = datetime.now()\\n self.pdf_name = (\\n self.pdf_name + \\\"_\\\" + my_datetime.strftime(\\\"%H%M_%d%m%Y\\\") + \\\".pdf\\\"\\n )\\n fig_width = aW * self.column_ratio[0]\\n\\n clm_width_meta = (aW * self.column_ratio[1]) / len(self.fields)\\n\\n c = canvas.Canvas(os.path.join(self.pdf_folder, self.pdf_name), pagesize=A4)\\n\\n for qc_run_id, fig_file in sorted(self._files.items()):\\n (param_values, feature_values) = get_param_values(\\n qc_run_id, self.db_name, return_meta_add_on=True\\n )\\n\\n comment = self.subject + \\\"<br/>\\\"\\n # c.saveState()\\n title = \\\"Dataset \\\" + qc_run_id\\n\\n # Prepare header\\n header = Paragraph(title, title_style)\\n h_w, h_h = header.wrap(aW, aH)\\n\\n # Prepare image\\n img = ImageReader(fig_file)\\n im_width, im_height = img.getSize()\\n aspect = im_height / float(im_width)\\n fig_height = fig_width * aspect\\n\\n # Prepare metadata section\\n\\n meta_table = Table(\\n param_values,\\n colWidths=[clm_width_meta] * len(self.fields),\\n hAlign=\\\"CENTER\\\",\\n rowHeights=0.22 * inch,\\n )\\n meta_table.setStyle(\\n TableStyle(\\n [\\n (\\\"FONT\\\", (0, 0), (-1, 0), \\\"Helvetica-Bold\\\"),\\n (\\\"FONT\\\", (0, 1), (-1, -1), \\\"Helvetica\\\"),\\n (\\\"LINEBELOW\\\", (0, 0), (1, 0), 0.08, colors.black),\\n (\\\"SIZE\\\", (0, 0), (-1, -1), 8),\\n (\\\"VALIGN\\\", (0, 0), (-1, -1), \\\"BOTTOM\\\"),\\n # ('ALIGN', (0, 0), (-1, 0), 'CENTER'),\\n (\\\"ALIGN\\\", (0, 0), (0, -1), \\\"LEFT\\\"),\\n (\\\"ALIGN\\\", (1, 1), (1, -1), \\\"LEFT\\\"),\\n (\\\"INNERGRID\\\", (0, 0), (-1, -1), 0.08, colors.beige),\\n # ('BOX', (0,0), (-1,-1), 0.25, colors.grey),\\n ]\\n )\\n )\\n\\n meta_width, meta_height = meta_table.wrap(aW - im_width, aH / 2)\\n\\n # Prepare comments header\\n comments_header = Paragraph(\\\"Comments:\\\", title_style)\\n avail_height = aH - fig_height - v_padding\\n comm_h_width, comm_h_height = comments_header.wrap(\\n im_width, avail_height # aW - meta_width,\\n )\\n # Prepare comments\\n my_datetime = datetime.now()\\n ts = \\\"Printed on \\\" + my_datetime.strftime(\\\"%c\\\")\\n\\n try:\\n data_specific_comment = self.comments[int(qc_run_id)]\\n comment += data_specific_comment + \\\"<br/>\\\"\\n comment += self.comments[\\\"general\\\"] + \\\"<br/>\\\"\\n\\n comment += self.smalltalk + \\\"<br/>\\\"\\n except Exception:\\n logger.warning(\\n \\\"Unable to summarize result of \\\" + \\\"dataset {}\\\".format(qc_run_id)\\n )\\n comment_ts = comment + ts\\n comment_ts = textwrap.fill(comment_ts, 70)\\n comment_ts = comment_ts.replace(\\\"\\\\n\\\", \\\"<br/>\\\")\\n\\n comments_p = Paragraph(comment_ts, body_style)\\n\\n avail_height = aH - fig_height - v_padding - comm_h_height\\n\\n comm_width, comm_height = comments_p.wrap(im_width, avail_height) # aW,\\n\\n line_widths = comments_p.getActualLineWidths0()\\n number_of_lines = len(line_widths)\\n if number_of_lines > 1:\\n pass\\n if number_of_lines == 1:\\n min(line_widths)\\n comm_width, comm_height = comments_p.wrap(im_width, avail_height)\\n\\n # Prepare features\\n feat_table = Table(\\n feature_values,\\n colWidths=[clm_width_meta] * len(self.fields),\\n hAlign=\\\"CENTER\\\",\\n rowHeights=0.22 * inch,\\n )\\n feat_table.setStyle(\\n TableStyle(\\n [\\n (\\\"FONT\\\", (0, 0), (-1, 0), \\\"Helvetica-Bold\\\"),\\n (\\\"FONT\\\", (0, 1), (-1, -1), \\\"Helvetica\\\"),\\n (\\\"LINEBELOW\\\", (0, 0), (1, 0), 0.08, colors.black),\\n (\\\"SIZE\\\", (0, 0), (-1, -1), 8),\\n (\\\"VALIGN\\\", (0, 0), (-1, -1), \\\"BOTTOM\\\"),\\n # ('ALIGN', (0, 0), (-1, 0), 'CENTER'),\\n (\\\"ALIGN\\\", (0, 0), (0, -1), \\\"LEFT\\\"),\\n (\\\"ALIGN\\\", (1, 1), (1, -1), \\\"LEFT\\\"),\\n (\\\"INNERGRID\\\", (0, 0), (-1, -1), 0.08, colors.beige),\\n # ('BOX', (0,0), (-1,-1), 0.25, colors.grey),\\n ]\\n )\\n )\\n avail_height = aH - meta_height # fig_height - v_padding - comm_h_height\\n avail_height -= comm_height\\n feat_width, feat_height = feat_table.wrap(aW - im_width, avail_height)\\n\\n # Draw everyting on canvas\\n\\n header.drawOn(c, left_margin, aH - top_margin)\\n\\n c.drawImage(\\n img,\\n left_margin,\\n aH - top_margin - fig_height - v_padding,\\n width=fig_width * 1.1,\\n height=fig_height * 1.1,\\n mask=\\\"auto\\\",\\n )\\n\\n meta_table.drawOn(\\n c,\\n left_margin + fig_width + h_padding,\\n aH - meta_height - top_margin / 2, # - v_padding\\n )\\n\\n comments_header.drawOn(\\n c,\\n left_margin,\\n aH\\n - top_margin\\n - comm_h_height\\n - fig_height\\n - 2 * v_padding, # - add_on_height\\n )\\n\\n comments_p.drawOn(\\n c,\\n left_margin,\\n aH\\n - top_margin\\n - comm_h_height\\n - comm_height\\n - fig_height\\n - 2 * v_padding\\n - comm_h_height, # - add_on_height\\n )\\n\\n feat_table.drawOn(\\n c,\\n left_margin + fig_width + h_padding,\\n aH - meta_height - top_margin / 2 - feat_height - v_padding,\\n # top_margin - fig_height - 2*v_padding - feat_height\\n )\\n\\n # new page\\n c.showPage()\\n c.saveState()\\n\\n c.save()\",\n \"def generate():\\n\\n # Verify if directory exists\\n if not os.path.isdir(config.techniques_markdown_path):\\n os.mkdir(config.techniques_markdown_path)\\n\\n #Write the technique index.html page\\n with open(os.path.join(config.techniques_markdown_path, \\\"overview.md\\\"), \\\"w\\\", encoding='utf8') as md_file:\\n md_file.write(config.technique_overview_md)\\n\\n for domain in config.domains:\\n generate_domain_markdown(domain)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6422397","0.64200485","0.63599217","0.63230777","0.6303222","0.6295382","0.61533386","0.6144586","0.60924774","0.60924774","0.60924774","0.60327756","0.6032378","0.5982227","0.59735847","0.59703684","0.59529877","0.59529877","0.5898977","0.58841336","0.5870176","0.5850822","0.5848896","0.5828459","0.57581556","0.5756515","0.5746069","0.5736085","0.5672274","0.5664064","0.56640404","0.56564844","0.5626091","0.56251144","0.5623838","0.560384","0.5603479","0.5598204","0.55767906","0.5561955","0.55558145","0.55509645","0.55466586","0.55426455","0.55391264","0.5523194","0.5512334","0.54934806","0.5462534","0.54617506","0.5447311","0.5428875","0.5428755","0.5424729","0.54072165","0.5406432","0.5405468","0.53877246","0.5380065","0.5372433","0.53553665","0.5350138","0.53477657","0.53341585","0.53330874","0.5323202","0.52968735","0.5286421","0.52855456","0.5276215","0.52573717","0.52540135","0.5251697","0.5250695","0.5250383","0.5245996","0.52425367","0.52361834","0.52313495","0.52288705","0.52159226","0.52018535","0.519944","0.5196533","0.5186024","0.5182775","0.5166796","0.51640195","0.5153721","0.5152513","0.5151246","0.515014","0.5142871","0.51414174","0.513974","0.51282346","0.5126378","0.5118604","0.51122165","0.51107174"],"string":"[\n \"0.6422397\",\n \"0.64200485\",\n \"0.63599217\",\n \"0.63230777\",\n \"0.6303222\",\n \"0.6295382\",\n \"0.61533386\",\n \"0.6144586\",\n \"0.60924774\",\n \"0.60924774\",\n \"0.60924774\",\n \"0.60327756\",\n \"0.6032378\",\n \"0.5982227\",\n \"0.59735847\",\n \"0.59703684\",\n \"0.59529877\",\n \"0.59529877\",\n \"0.5898977\",\n \"0.58841336\",\n \"0.5870176\",\n \"0.5850822\",\n \"0.5848896\",\n \"0.5828459\",\n \"0.57581556\",\n \"0.5756515\",\n \"0.5746069\",\n \"0.5736085\",\n \"0.5672274\",\n \"0.5664064\",\n \"0.56640404\",\n \"0.56564844\",\n \"0.5626091\",\n \"0.56251144\",\n \"0.5623838\",\n \"0.560384\",\n \"0.5603479\",\n \"0.5598204\",\n \"0.55767906\",\n \"0.5561955\",\n \"0.55558145\",\n \"0.55509645\",\n \"0.55466586\",\n \"0.55426455\",\n \"0.55391264\",\n \"0.5523194\",\n \"0.5512334\",\n \"0.54934806\",\n \"0.5462534\",\n \"0.54617506\",\n \"0.5447311\",\n \"0.5428875\",\n \"0.5428755\",\n \"0.5424729\",\n \"0.54072165\",\n \"0.5406432\",\n \"0.5405468\",\n \"0.53877246\",\n \"0.5380065\",\n \"0.5372433\",\n \"0.53553665\",\n \"0.5350138\",\n \"0.53477657\",\n \"0.53341585\",\n \"0.53330874\",\n \"0.5323202\",\n \"0.52968735\",\n \"0.5286421\",\n \"0.52855456\",\n \"0.5276215\",\n \"0.52573717\",\n \"0.52540135\",\n \"0.5251697\",\n \"0.5250695\",\n \"0.5250383\",\n \"0.5245996\",\n \"0.52425367\",\n \"0.52361834\",\n \"0.52313495\",\n \"0.52288705\",\n \"0.52159226\",\n \"0.52018535\",\n \"0.519944\",\n \"0.5196533\",\n \"0.5186024\",\n \"0.5182775\",\n \"0.5166796\",\n \"0.51640195\",\n \"0.5153721\",\n \"0.5152513\",\n \"0.5151246\",\n \"0.515014\",\n \"0.5142871\",\n \"0.51414174\",\n \"0.513974\",\n \"0.51282346\",\n \"0.5126378\",\n \"0.5118604\",\n \"0.51122165\",\n \"0.51107174\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58279645"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":9458,"cells":{"query":{"kind":"string","value":"List known Data Docs Sites."},"document":{"kind":"string","value":"def docs_list(directory):\n context = toolkit.load_data_context_with_error_handling(directory)\n\n docs_sites_url_dicts = context.get_docs_sites_urls()\n docs_sites_strings = [\n \" - <cyan>{}</cyan>: {}\".format(\n docs_site_dict[\"site_name\"],\n docs_site_dict.get(\"site_url\")\n or f\"site configured but does not exist. Run the following command to build site: great_expectations \"\n f'docs build --site-name {docs_site_dict[\"site_name\"]}',\n )\n for docs_site_dict in docs_sites_url_dicts\n ]\n\n if len(docs_sites_strings) == 0:\n cli_message(\"No Data Docs sites found\")\n else:\n list_intro_string = _build_intro_string(docs_sites_strings)\n cli_message_list(docs_sites_strings, list_intro_string)\n\n toolkit.send_usage_message(\n data_context=context, event=\"cli.docs.list\", success=True\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 find_all(client):\n return list(map(lambda s: Site(s), client.get_api_resource(\"self/sites\")))","def list_sites():\n sites = db_client.query_sites_list()\n return jsonify(sites)","def list_sites():\n result = []\n querystring = 'select sitename from {};'.format(TABLES[0]))\n res = execute_query(querystring)\n if res:\n result = [x[0] for x in res]\n return result","def get_list_of_sites(self):\n\n return self.site_db_obj.get_list_of_sites()","def get_list_of_sites(self) -> list:\n ah_write = self.get_iis_object()\n section = ah_write.GetAdminSection(\"system.applicationHost/sites\", \"MACHINE/WEBROOT/APPHOST\")\n collection = section.Collection\n result = []\n\n for i in range(collection.Count):\n\n site = collection[i]\n prop = site.Properties\n # site_id = prop[\"id\"].Value\n name = prop[\"name\"].Value\n default_app = self.get_default_app(site)\n bindings = self.get_site_bindings(site.ChildElements)\n applications = self.get_applications(site)\n if default_app and not os.path.exists(self.core.expandvars(default_app[\"physicalPath\"])):\n # не показывать сайты для которых нет физ. директории для иис экспреса\n continue\n site = Site(name, bindings, default_app, applications)\n if hasattr(site, 'port') and site.port != 0:\n result.append(site)\n\n return result","def sites(self):\n return self.properties.get('sites',\n SiteCollection(self.context, ResourcePath(\"sites\", self.resource_path)))","def Sites(self):\n if self._sites is None or len(self._sites) == 0:\n return None\n return self._sites","def sites(self):\n return self.data.sites.values","def load_sites(self, site_list: list = None):\n try:\n sites = self.api.get(host=self.host, endpoint=f\"/api/v1/orgs/{self.oid}/sites\")\n except Exception as e:\n logger.error(f\"{TextColors.FAIL}Error getting org sites:{TextColors.ENDC} {e}\")\n raise e\n if site_list:\n sites = [s for s in sites if s['name'] in site_list]\n self.sites = sites","def list_sites(NextToken=None, MaxResults=None):\n pass","def _sites(self):\n return self.properties.get('sites',\n SitePropertiesCollection(self.context, ResourcePath(\"sites\", self.resource_path)))","def list_site_data(site_name):\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n\n sitedoc = {'_id': siteid, 'name': site_name, 'settings': _get_settings(siteid)}\n\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\n querystring = 'select id, dirname from {} where site_id = %s;'.format(TABLES[2])\n result = execute_query(querystring, (siteid,))\n dirmap = {row['id']: row['dirname'] for row in result}\n dirids = [x for x in dirmap]\n sitedoc['docs'] = {x: {} for x in dirmap.values()}\n\n querystring = ('select docname, source_docid, source_updated, source_deleted, target_docid, '\n 'target_updated, target_deleted, mirror_updated, dir_id from {} '\n 'where dir_id = any(%s);'.format(TABLES[3]))\n result = execute_query(querystring, (dirids,))\n docstats, docnames = [], {}\n for row in result:\n doc, dir = row['docname'], dirmap[row['dir_id']]\n docitem = doc if dir == '/' else '/'.join((dir, doc))\n ## docstats.append((dir, doc,\n ## ('src', {'docid': row['source_docid'], 'updated': row['source_updated']}),\n ## ('dest', {'docid': row['target_docid'], 'updated': row['target_updated']}),\n ## ('to_mirror', {'updated': row['mirror_updated']})))\n docdata = [dir, doc]\n sourcedoc, destdoc = {}, {}\n if row['source_docid'] is not None:\n sourcedoc['docid'] = row['source_docid']\n if row['source_updated'] is not None:\n sourcedoc['updated'] = row['source_updated']\n if row['source_deleted'] is not None:\n sourcedoc['deleted'] = row['source_deleted']\n if sourcedoc:\n docdata.append(('src', sourcedoc))\n if row['target_docid'] is not None:\n destdoc['docid'] = row['target_docid']\n if row['target_updated'] is not None:\n destdoc['updated'] = row['target_updated']\n if row['target_deleted'] is not None:\n destdoc['deleted'] = row['target_deleted']\n if destdoc:\n docdata.append(('dest', destdoc))\n if row['mirror_updated'] is not None:\n docdata.append(('mirror', {'updated': row['target_updated']}))\n docstats.append(tuple(docdata))\n docnames[row['source_docid']] = (docitem, 'src')\n docnames[row['target_docid']] = (docitem, 'dest')\n\n for dir, doc, *items in sorted(docstats):\n sitedoc['docs'][dir][doc] = {x: y for x, y in items}\n ## if item[0] != olddir:\n ## if olddir:\n ## sitedoc['docs'][olddir] = dirdict\n ## olddir = item[0]\n ## dirdict = {}\n ## dirdict[item[1]] = {x:y for x, y in item[2:]}\n ## if olddir:\n ## [olddir] = dirdict\n\n data = []\n querystring = 'select id, currtext, previous from {} where id = any(%s)'.format(TABLES[4])\n result = execute_query(querystring, ([x for x in docnames],))\n for row in result:\n data.append({'_id': docnames[row['id']], 'current': row['currtext'],\n 'previous': row['previous']})\n\n querystring = 'select name, text from {} where site_id = %s;'.format(TABLES[5])\n result = execute_query(querystring, (siteid,))\n for row in result:\n data.append({'_id': (row['name'],), 'template contents': row['text']})\n\n\n\n return sitedoc, sorted(data, key=lambda x: x['_id'])","def list_websites(self):\r\n\r\n # Fetch websites\r\n self.fetch_website_list()\r\n\r\n # Print website data\r\n for website in self.website_list:\r\n print(\"ID: {0} | Domain: {1} | Name: {2}\".format(\r\n website['id'], website['domain'], website['name']))","def sites(self):\n return self._sites","def sites(self):\n return self._sites","def list_sites(keys):\n key_store = KeyStore(get_config_file())\n for site, key in key_store.list_sites().iteritems():\n if keys:\n click.echo(\"{} = {}\".format(site, key))\n else:\n click.echo(site)","def get_docs_urls(self):\n docs_urls = []\n link_labels = []\n for tag in self.post_div.find_all(\"a\"):\n url = tag[\"href\"]\n if url.startswith(\"https://docs.google.com\") or \\\n url.startswith(\"https://drive.google.com\"):\n docs_urls += [url]\n link_labels += [tag.text]\n return docs_urls, link_labels","def get_site_list():\n log = current_app.log\n db = request.db\n user_id = SiteService.get_current_uid()\n Site = db.tables.Site\n site_list = []\n sites = Site.query.all()\n for site_entry in sites:\n # Ensure user can only see the correct sites\n is_owner = False\n is_visible = False\n if site_entry.site_owner == user_id:\n is_owner = True\n is_visible = True\n elif site_entry.public:\n is_visible = True\n if not is_visible:\n continue\n # Build the output object\n cur_site = {\"is_owner\": is_owner,\n \"public\": site_entry.public}\n for key in (\"site_id\", \"site_name\", \"site_desc\", \"def_path\"):\n cur_site[key] = getattr(site_entry, key)\n site_list.append(cur_site)\n log.info(\"Found %u sites for user id %u.\", len(site_list), user_id)\n return jsonify(site_list)","def sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WebChatSiteArgs']]]]:\n return pulumi.get(self, \"sites\")","def getListOfSites(self):\n with self.config.TaskWorker.envForCMSWEB:\n sites = self.resourceCatalog.getAllPSNs()\n filteredSites = [site for site in sites if not site.startswith(\"T1_\")]\n\n return filteredSites","def iter_sites(self):\n return iter(self.site_list)","def get_sites():\n #sites = sys.argv[1:] # Accept sites from command line input\n\n # Read in additional sites to monitor from sites.txt file\n try:\n sites = [site.strip() for site in io.open('sites.txt', mode='r').readlines()]\n except IOError:\n print (colorize(\"No sites.txt file found\", \"red\"))\n\n # Add protocol if missing in URL\n for site in range(len(sites)):\n if sites[site][:7] != \"http://\" and sites[site][:8] != \"https://\":\n sites[site] = \"http://\" + sites[site]\n\n # Eliminate exact duplicates in sites\n sites = list(set(sites))\n\n return sites","def get_sites():\n results = __gae_fetch('https://api.stackexchange.com/%s/sites?pagesize=999&key=%s' % (__api_version, api_key))\n response = simplejson.loads(results.content)\n return response","def sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DirectLineSiteArgs']]]]:\n return pulumi.get(self, \"sites\")","def get_sites():\n sites_file = open(FILENAME)\n sites = []\n for site in sites_file:\n sites.append(\"http://\" + site.strip())\n return sites","def get_sites():\n sites_file = open(FILENAME)\n sites = []\n for site in sites_file:\n sites.append(\"http://\" + site.strip())\n return sites","def list_domain_names():\n pass","def getSites(self):\n return self.SelectedSites","def get_docs_sources(self):\n docs = [doc for doc,_,_ in self.doc_to_get]\n \n retry_until_ok(self.docman.elastic.indices.refresh, index=\"\")\n documents = self.docman.elastic.mget(body={'docs': docs})\n return documents","def getVCDRSites(**kwargs):\n strVCDRProdURL = kwargs['strVCDRProdURL']\n sessiontoken = kwargs['sessiontoken']\n if kwargs['cloud_fs_id'] is None:\n print(\"Please specify the ID of the cloud file system using '-cloud-fs-id'\")\n sys.exit(1)\n cloud_fs_id = kwargs['cloud_fs_id']\n if kwargs['site_id'] is None:\n json_response = get_vcdr_sites_json(strVCDRProdURL, cloud_fs_id, sessiontoken)\n if json_response == None:\n print(\"API Error\")\n sys.exit(1)\n sites = json_response[\"protected_sites\"]\n table = PrettyTable(['Site Name', 'Site ID'])\n for i in sites:\n table.add_row([i['name'], i['id']])\n print(table)\n else:\n site_id = kwargs['site_id']\n json_response = get_vcdr_site_details_json(strVCDRProdURL, cloud_fs_id, site_id, sessiontoken)\n if json_response == None:\n print(\"API Error\")\n sys.exit(1)\n print(\" \")\n print(f\"Site Name: {json_response['name']}\")\n print(f\"Site Type: {json_response['type']}\")\n print(\" \")","def iter_sites(self):\n if self.default_model:\n return self.default_model.iter_sites()\n return iter(list())","def dorkScanner():\n pysearch.PySearch()\n openfile = open(\"sites.txt\", 'r')\n urls = openfile.read()\n openfile.close()\n return urls","def list_docs(site_name, doctype='', directory='', deleted=False):\n if not directory:\n directory = '/'\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n dirid = _get_dir_id(siteid, directory)\n if dirid is None:\n raise FileNotFoundError('no_subdir')\n\n ## doclist = _get_docs_in_dir(dirid)\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\n querystring = ('select docname, source_docid, source_deleted, target_docid, target_deleted, '\n 'mirror_updated from {} where dir_id = %s;')\n result = execute_query(querystring.format(TABLES[3]), (dirid,))\n doclist = []\n for row in cur:\n # print(doctype, row['source_docid'], deleted, row['source_deleted'])\n add = False\n if doctype in ('', 'src') and row['source_docid']:\n # print(row['source_deleted'])\n add = bool(row['source_deleted']) == deleted\n elif doctype == 'dest' and row['target_docid']:\n add = bool(row['target_deleted']) == deleted\n elif doctype == 'mirror' and row['mirror_updated']:\n add = not deleted\n if add:\n doclist.append(row['docname'])\n\n return doclist # returns all documents of the given type","def getDocsList(self):\n return self.docs_list","def urls(self):\n return self._list_urls()","def urls(self) -> list[str]:\r\n ...","def fetch_website_list(self):\r\n # Clear list\r\n self.website_list = []\r\n\r\n # Open websites overview\r\n self.browser.open(self.config[\"base_url\"] + \"websites\")\r\n\r\n # Find table and iterate over rows\r\n for table_row in self.browser.get_current_page().select(\"table tr\"):\r\n\r\n # Fetch cells\r\n cells = table_row.findAll('td')\r\n\r\n # Iterate over cells\r\n if(len(cells) > 0):\r\n\r\n # Get website ID\r\n website_id = table_row['data-id']\r\n # Get website name\r\n name = cells[1].text.strip()\r\n # Get website domain name\r\n domain = cells[2].text.strip()\r\n\r\n # Build website object\r\n website = {'id': website_id,\r\n 'name': name, 'domain': domain}\r\n\r\n # Add website object to list\r\n self.website_list.append(website)","def get_observing_sites(self):\n pass","def get(self):\n try:\n sites = Site.query.all()\n except OperationalError:\n raise InternalServerError(description='Site table does not exists.')\n return sites, 200","def get_sites():\n sites = [ x.get('siteid') for x in Schedconfig.objects.values('siteid').distinct() ]\n locale.setlocale(locale.LC_ALL, '')\n sites = sorted(sites, key=locale.strxfrm)\n return sites","def _get_sites(web_crawl):\n site_list = \"\"\n if 'primarySite' in web_crawl:\n site_list = web_crawl['primarySite'] \n else:\n # TODO: throw exception, must have primary site\n pass\n if 'additionalSites' in web_crawl:\n for site in web_crawl['additionalSites']:\n site_list += \",\" + site\n return site_list","def get_supported_sites(self, all=False):\n if all:\n return self.supported_sites.keys()\n else:\n return [site_name for (site_name, site) in self.supported_sites.items() if site.enabled]","def list_all():\n\n return (_conn.listDefinedDomains() +\n [_conn.lookupByID(id).name() for id in _conn.listDomainsID()])","def get_input_domains():\n df = pandas.read_excel(\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\", engine=\"odf\")\n list_of_addresses = df['Domain'].to_list()\n list_of_addresses = [(\"http://\" + address) for address in list_of_addresses]\n print(list_of_addresses)\n return list_of_addresses","def get_vhosts( self ):\n self.sites_available = []\n self.created_RE = re.compile( '#VirtualHost created by localsite.py' )\n vlogging.ret_logger.debug( 'listing localsites now' )\n available_dir = '/etc/apache2/sites-available'\n sites_available = os.listdir( available_dir )\n vlogging.ret_logger.info( sites_available )\n sites_enabled = os.listdir( '/etc/apache2/sites-enabled' ) \n for item in sites_available:\n file_path = os.path.join( available_dir, item )\n if os.path.isfile( file_path ):\n f = open( file_path, 'rb' )\n # Check to see if the site was created by vhosts.py\n if self.created_RE.match( f.read( 36 ) ):\n if item in sites_enabled:\n enabled = True\n else:\n enabled = False\n vhost = VirtualHost( item, enabled )\n self.sites_available.append( vhost )\n f.close()\n return self.sites_available","def GetDocumentListFeed(self):\n q = gdata.docs.service.DocumentQuery();\n return self.QueryDocumentListFeed(q.ToUri())","def get_all_site_names(_current_parser=None):\n parser = _get_parser(_current_parser)\n return [site for site in parser if site != \"DEFAULT\"]","def build_sites_list():\n ns_getsites_filter = '''\n <nc:filter type=\"xpath\"\n xmlns:nc=\"urn:ietf:params:xml:ns:netconf:base:1.0\"\n xmlns:rm=\"http://cisco.com/ns/yang/Cisco-IOS-XE-route-map\"\n select=\"/native/route-map[substring(name, 1, 3)='To_']/name\"\n />\n '''\n m = manager.connect( host='10.112.83.100',\n port=830,\n username='cisco',\n password='cisco',\n hostkey_verify=False)\n answer = m.get_config(source='running', filter=ns_getsites_filter).data_xml\n c = xmltodict.parse (answer)\n # build the list\n liste_sites = [ r['name'][3:] for r in c['data']['native']['route-map'] ]\n return liste_sites","def get_site_designs(context, include_untargeted=True, store=None):\n return_type = ClientResult(context, ClientValueCollection(SiteDesignMetadata))\n utility = SiteScriptUtility(context)\n payload = {\n \"includeUntargeted\": include_untargeted,\n \"store\": store\n }\n qry = ServiceOperationQuery(utility, \"GetSiteDesigns\", None, payload, None, return_type)\n qry.static = True\n context.add_query(qry)\n return return_type","def getNSites(self):\n return self.nsites","def get_all(self, search_string: str = None) -> Dict[str, Any]:\n headers = self._setup_headers_with_sail_json()\n all_site_resp = self.interactor.get_page(_Sites.TEMPO_SITE_PAGE_NAV, headers=headers, label=\"Sites.SiteNames\")\n all_site_json = all_site_resp.json()\n for site_info in extract_values(all_site_json, '#t', 'SitePageLink'):\n if 'siteUrlStub' in site_info:\n site_url_stub = site_info['siteUrlStub']\n self.get_site_data_by_site_name(site_url_stub)\n return self._sites","def URLs(self, default=[{}]):\n tmp = self.data.get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def build_docs(context, site_name=None, view=True, assume_yes=False):\n logger.debug(\"Starting cli.datasource.build_docs\")\n\n if site_name is not None:\n site_names = [site_name]\n else:\n site_names = None\n index_page_locator_infos = context.build_data_docs(\n site_names=site_names, dry_run=True\n )\n\n msg = \"\\nThe following Data Docs sites will be built:\\n\\n\"\n for site_name, index_page_locator_info in index_page_locator_infos.items():\n msg += \" - <cyan>{}:</cyan> \".format(site_name)\n msg += \"{}\\n\".format(index_page_locator_info)\n\n cli_message(msg)\n if not assume_yes:\n toolkit.confirm_proceed_or_exit()\n\n cli_message(\"\\nBuilding Data Docs...\\n\")\n context.build_data_docs(site_names=site_names)\n\n cli_message(\"Done building Data Docs\")\n\n if view:\n context.open_data_docs(site_name=site_name, only_if_exists=True)","def get_urls():\r\n return []","def URLs(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def get_datasource_list():\n global datasource_list\n\n if not datasource_list:\n datasource_list = stixhelpers.get_datasources(get_srcs())\n\n return datasource_list","def get_sites(self, filter_term=None):\n\n self.logger.debug(\"getting sites from Netlify\")\n\n if Cache.get(self.CACHE_KEY):\n self.logger.debug(\"Loading from cache\")\n return self.filter_sites(Cache.get(self.CACHE_KEY), filter_term)\n\n headers = {\n \"Authorization\": \"Bearer {}\".format(\n self.access_token),\n \"Accept\": \"application/json\",\n \"User-Agent\": \"Ulauncher-Netlify\"}\n req = requests.get(self.API_BASE_URL + '/sites/', headers=headers)\n\n if not req.ok:\n if req.status_code == 401:\n raise AuthenticationException(\n \"Failed to authenticate with access token \" + self.access_token)\n\n raise GenericException(\n \"Error connecting to Netlify API : status \" + req.status_code)\n\n data = req.json()\n\n Cache.set(self.CACHE_KEY, data, self.CACHE_TTL)\n\n return self.filter_sites(data, filter_term)","def _find_sites_for_user(email):\n sitez = set()\n for g in groups.find({\"users\":email}):\n for s in g['sites']:\n sitez.add(s)\n return list(sitez)","def getURLs():","def getSitesData( self ):\n if self.lastDataRetrievalTime - time.time() < 300:\n result = self.__getRPCClient().getSitesData()\n if 'rpcStub' in result:\n del( result[ 'rpcStub' ] )\n if not result[ 'OK' ]:\n return result\n self.sitesData = result[ 'Value' ]\n if self.sitesData:\n self.lastDataRetrievalTime = time.time()\n return S_OK( self.sitesData )","def api_list(self):\n return self._get('apis')","def getUrlsList(self):\n\t\ttry:\n\t\t\tf = ur.urlopen(self.sitemap_url)\n\t\t\tres = f.readlines()\n\t\t\tfor d in res:\n\t\t\t data = re.findall('<loc>(https?:\\/\\/.+?)<\\/loc>',d)\n\t\t\t for i in data:\n\t\t\t\tself.urls.append(i)\n\t\texcept Exception as e:\n\t\t\tself.app.printflush(str(e))\n\t\t\tself.app.printflush(traceback.format_exc())\n\t\tself.fetched_count = len(self.urls)","def sites(self) -> Sequence[LatticeSite]:\n return self._sites","def search(url, domain_list):\n resp = requests.get(url)\n if not resp.json().get('hits', '').get('hits', []):\n return\n for hit in resp.json()[\"hits\"][\"hits\"]:\n domain = hit.get(\"_source\", {}).get(\"domain\", \"\")\n if not domain:\n continue\n if not domain in domain_list:\n domain_list.append(domain)\n #print(hit[\"_source\"].get(\"title\", \"\").encode(\"ascii\",\"ignore\"))\n if domain not in ALLOWED_DOMAINS:\n print(domain)","def get_indexes(self):\n resources = []\n\n data = self.get_resource_data(type='sources')\n data['url'] = constants.URLS['sources'] % data\n resources.append(data)\n\n for arch in self.data['arch']:\n data = self.get_resource_data(type='packages', arch=arch)\n data['url'] = constants.URLS['packages'] % data\n resources.append(data)\n return resources","def urls(self) -> str:\n return self._data['urls']","def urls(self):\n days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', ]\n url = 'http://www2.nngov.com/newport-news/offenses/%stxt.htm'\n return [url % day for day in days]","def list_dirs(site_name, doctype=''):\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n\n ## probable inefficient approach\n ## for dir_id in dirids:\n ## docs = _get_docs_in_dir(dir_id)\n ## for docname in docs:\n ## docids = _get_doc_ids(dir_id, docname)\n ## if docids[1] is not None:\n ## diridlist.append(dir_id)\n querystring = 'select id, dirname from {} where site_id = %s;'\n result = execute_query(querystring.format(TABLES[2]), (siteid,))\n dirmap = {row['id']: row['dirname'] for row in result}\n dirids = [x for x in dirmap]\n if doctype in ('', 'src'):\n pass\n elif doctype == 'dest':\n querystring = 'select dir_id, target_docid from {} where dir_id = any(%s);'\n result = execute_query(querystring.format(TABLES[3]), (dirids,))\n dirids = set()\n for row in result:\n if row['target_docid'] is not None:\n dirids.add(row['dir_id'])\n else:\n raise RuntimeError('wrong doctype for list_dirs')\n dirlist = []\n for id in dirids:\n test = dirmap[id]\n if test != '/':\n dirlist.append(test)\n return dirlist # returns all dirs that have documents of the given type","def getDocuments(self):\n documents = []\n\n for document in self.metaData.jsonObj['documents']:\n d = HyperLinkResource(document)\n documents.append(Document(self._client, d.selfLink))\n\n return documents","def list_domain_names(self) -> Dict:\n pass","def start_urls(self):\n if self.agency_doc_id or self.dept_doc_id:\n agency_doc_id = self.agency_doc_id\n if isinstance(agency_doc_id, list):\n agency_doc_id = agency_doc_id[0]\n return [\n \"https://detroitmi.gov/documents?{}={}&{}={}\".format(\n self.doc_query_param_dept,\n self.dept_doc_id,\n self.doc_query_param,\n agency_doc_id or \"\",\n )\n ]\n else:\n return [self.get_event_start_url()]","def GetSlavesForHost():\n hostname = os.getenv('TESTING_SLAVENAME')\n if not hostname:\n hostname = socket.getfqdn().split('.', 1)[0].lower()\n return [s for s in GetAllSlaves() if s.get('hostname') == hostname]","def get_all_doc_stats(site_name):\n siteid = _get_site_id(site_name)\n if siteid is None:\n raise FileNotFoundError('no_site')\n\n dirids = _get_all_dir_ids(siteid)\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\n querystring = 'select dirname from {} where site_id = %s;'.format(TABLES[2])\n result = execute_query(querystring, (siteid,))\n dirnames = [row['dirname'] for row in result]\n querystring = ('select dirname, docname, source_updated, target_updated, mirror_updated,'\n ' source_deleted, target_deleted from {0}, {1} where dir_id = {1}.id'\n ' and dir_id = any(%s);'.format(TABLES[3], TABLES[2]))\n result = execute_query(querystring, (dirids,))\n all_stats = [(row['dirname'],\n row['docname'],\n _get_stats((row['source_updated'], row['target_updated'], row['mirror_updated'])))\n for row in result if not any((row['source_deleted'], row['target_deleted']))]\n\n stats_list = []\n for name in sorted(dirnames):\n cp = functools.partial(_is_equal, y=name)\n dirlist = filter(cp, all_stats) # Pylint: using a list comprehension can be clearer?\n stats_list.append((name, [x[1:] for x in dirlist]))\n\n return stats_list","def fetch_list(self):\n\t\treturn self.fetch(self.list_url % ART_SERVER_HOST)","def list_pd(cls, pss_url):\n pds_url = cls.__get_url(pds_url)\n logger.debug(\"List PDS at %s\"%pds_url)\n pds_dir = saga.advert.directory(pds_url, saga.advert.Create | \n saga.advert.CreateParents | \n saga.advert.ReadWrite)\n \n pd_list = pds_dir.list()\n pd_full_urls = []\n for i in pd_list:\n pd_full_urls.append(pss_url + \"/\" + i) \n return pd_full_urls","def relevant_domains(self):\n pass","def get_org_list():\r\n\r\n resp = requests.get(''.join([Kegg.BASE_URL, 'list/organism']))\r\n return resp.text","def sites(self):\n struc = self.structure\n pots = self.potentials\n shapes = self.shapes\n\n _, new_pots = self._check_for_CPA(struc, pots)\n site_list = []\n for j in range(len(struc.sites)):\n site_list.append({\n 'StructureDataSite': struc.sites[j],\n 'potential': new_pots[j],\n 'shapefun': shapes[j % len(shapes)]\n })\n return site_list","def getListOfSDs(name = None,selector = None):\n sds = rhevGet(\"/api/datacenters/%s/storagedomains\"%getDcData(rhev_settings.DC,\"id\"))\n doc = libxml2.parseDoc(sds)\n ctxt = doc.xpathNewContext()\n res = ctxt.xpathEval(\"/storage_domains/storage_domain\")\n sdlist = []\n for sd in res:\n sdin = {}\n sdin[\"name\"] = sd.firstElementChild().get_content()\n sdin[\"id\"] = sd.prop(\"id\")\n sdlist.append(sdin)\n result = []\n if name:\n result = [sdin for sdin in sdlist if sdin[\"name\"].find(name) != -1]\n return result or sdlist","def get_site_feeds(url):\n url: str = remove_subdomains(url)\n\n site: SiteHost = db_client.query_site_feeds(url)\n\n if site:\n try:\n site_schema = ExternalSiteSchema()\n result = site_schema.dump(site)\n except ValidationError as err:\n app.logger.warning(\"Dump errors: %s\", err.messages)\n return abort(500)\n\n return jsonify(result)\n else:\n response = jsonify({\"message\": f\"No feed information saved for url {url}\"})\n response.status_code = 402\n return response","def show_list():\n\n response = []\n docs = SUPERHEROES.stream()\n for doc in docs:\n response.append(doc.to_dict())\n return jsonify(response), 201","def list_domain(self, feed_id=None):\n resources = self.list_resource(feed_id=feed_id, resource_type_id='Host Controller')\n domains = []\n if resources:\n for resource in resources:\n resource_data = self.get_config_data(\n feed_id=resource.path.feed_id, resource_id=resource.id)\n domain_data = resource_data.value\n domains.append(Domain(resource.id, resource.name, resource.path, domain_data))\n return domains","def _gather_data(dirpath: str, visible_sites: List[str] = None) -> Dict[str, List[Dict[str, Any]]]:\n parser = html5lib.HTMLParser(strict=True)\n\n results = []\n for path in os.walk(dirpath):\n site = path[0].rsplit(\"/\", 1)[1]\n if visible_sites and site not in visible_sites and site != \"global\":\n continue\n with open(os.path.join(dirpath, site, \"site.json\"), \"r\") as f:\n entity = json.loads(f.read())\n if site != \"global\":\n try:\n Site(**entity)\n except ValidationError as e:\n print(f\"Error processing site.json for {site}: {e.json()}\")\n raise e\n with open(os.path.join(dirpath, site, \"summary.html\"), \"r\") as f:\n summary = f.read()\n parser.parseFragment(summary)\n entity[\"summary\"] = summary\n results.append(entity) \n return {\"sites\" : results }","def get_urls(db):\n return db.meta.find_one({'name':\"urls\"})['urls']","def domains(self):\n return DomainCollection(self.request)","def list_servers(self, all_tenants=False):\n _url = \"http://\" + self.host_ip + \":8774/v2/\" + \\\n self.project_info[\"project_id\"] + \"/servers/detail\"\n if all_tenants:\n _url = \"http://\" + self.host_ip + \":8774/v2/\" + self.project_info[\n \"project_id\"] + \"/servers/detail?all_tenants=1\"\n _headers = {'x-auth-token': self.project_info[\"token_project\"],\n 'content-type': 'application/json'}\n _body = None\n response = self.request(\"GET\", _url, _headers, _body)\n if response is None:\n LOG_OBJ.error(\"No response from server while listing servers.\")\n return\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\"List servers Failed with status %s \" %\n response.status)\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"Servers List :%s \" % output)\n return output[\"servers\"]","def list_domain(self, feed_id=None):\n domains = self.list_resource(feed_id=feed_id,\n resource_type_id='Domain Host',\n cls=Domain,\n list_children=True,\n include_data=True)\n return domains","def get_local_schedds(schedd_base_name=socket.getfqdn()):\n schedd_list = []\n temp_list = htcondor.Collector().locateAll(htcondor.DaemonTypes.Schedd)\n for schedd in temp_list:\n if 'Name' not in schedd:\n continue\n if schedd_base_name in schedd['Name']:\n schedd_list.append(schedd)\n return schedd_list","def domains(cls):\n return [cls.domain]","def hosts(self) -> t.List[str]:\n if not self._hosts:\n self._hosts = self._get_db_hosts()\n return self._hosts","def getPublicEMPDownloadLinks(self):\n try:\n studies = []\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('get_public_emp_studies', [results])\n for row in results:\n # study_id, project_name, file_path, study_abstract\n studies.append((row[0], row[1], row[2], row[3]))\n return studies\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)","def get_downloadable_data(url_list):\n downloadable_data_list = []\n for url in url_list:\n soup = visit_homepage(url)\n for link in soup.find_all(class_='resource-url-analytics'):\n downloadable_data_list.append(link['href'])\n return downloadable_data_list","def tracking_domain_list(self):\r\n params = base.get_params(None, locals())\r\n return self._get('tracking_domain_list', params)","def listaServicios(self):\n portal_catalog = getToolByName(self, 'portal_catalog')\n mt = portal_catalog.searchResults(portal_type = 'ServeiTIC',\n path={\"query\": '/'.join(self.getParentNode().getParentNode().getPhysicalPath()),\"depth\":2},\n sort_on='Date')\n new_list=[]\n for f in mt:\n new_list.append(f.Title)\n new_list.sort()\n return new_list","def allSites(self, expandSeries=True):\n for siteNames in self._typeDict.values():\n for name in siteNames:\n site = getattr(self, name)\n if isinstance(site, IconSiteSeries):\n if expandSeries:\n for s in site.sites:\n yield s\n else:\n yield site\n elif isinstance(site, IconSite):\n yield site","def listsources():\n\tmain_url = \" https://newsapi.org/v2/sources?apiKey=5f81b593f35d42a8980313250c03d7e7\"\n\n\t# fetching data in json format \n\topen_source = requests.get(main_url).json() \n\n\t# getting all articles in a string sources\n\tsource = open_source[\"sources\"] \n\n\t# empty list which will \n\t# contain all trending newssources \n\tresults = [] \n\t\n\tfor k in source: \n results.append(k[\"id\"])\n \n \t\n\tfor w in results[0:4]:\n print(w)","def list(self):\n\t\treturn self.link_words","def importSites(self,sites_list):\n \"\"\" Append these sites objects to a sample \"\"\" \n self.sites = []\n for s in sites_list:\n mySite = Site(s)\n self._addSite(mySite)","def get_website_URLs():\n\tfilepath = os.path.dirname(os.path.realpath(__file__)) +\"/web_sources\"\n\tf = open(filepath, 'r')\n\twebsites = []\n\tfor line in f:\n\t\tif line != \"\\n\":\n\t\t\tendl_index = line.index('\\n')\n\t\t\tclean_line = line[:endl_index]\n\t\t\tnew_list = clean_line.split(' ', 1)\n\t\t\twebsites.append(new_list)\n\tf.close()\n\treturn websites","def company_lists(self):\n return self.client.get('company/named-lists')"],"string":"[\n \"def find_all(client):\\n return list(map(lambda s: Site(s), client.get_api_resource(\\\"self/sites\\\")))\",\n \"def list_sites():\\n sites = db_client.query_sites_list()\\n return jsonify(sites)\",\n \"def list_sites():\\n result = []\\n querystring = 'select sitename from {};'.format(TABLES[0]))\\n res = execute_query(querystring)\\n if res:\\n result = [x[0] for x in res]\\n return result\",\n \"def get_list_of_sites(self):\\n\\n return self.site_db_obj.get_list_of_sites()\",\n \"def get_list_of_sites(self) -> list:\\n ah_write = self.get_iis_object()\\n section = ah_write.GetAdminSection(\\\"system.applicationHost/sites\\\", \\\"MACHINE/WEBROOT/APPHOST\\\")\\n collection = section.Collection\\n result = []\\n\\n for i in range(collection.Count):\\n\\n site = collection[i]\\n prop = site.Properties\\n # site_id = prop[\\\"id\\\"].Value\\n name = prop[\\\"name\\\"].Value\\n default_app = self.get_default_app(site)\\n bindings = self.get_site_bindings(site.ChildElements)\\n applications = self.get_applications(site)\\n if default_app and not os.path.exists(self.core.expandvars(default_app[\\\"physicalPath\\\"])):\\n # не показывать сайты для которых нет физ. директории для иис экспреса\\n continue\\n site = Site(name, bindings, default_app, applications)\\n if hasattr(site, 'port') and site.port != 0:\\n result.append(site)\\n\\n return result\",\n \"def sites(self):\\n return self.properties.get('sites',\\n SiteCollection(self.context, ResourcePath(\\\"sites\\\", self.resource_path)))\",\n \"def Sites(self):\\n if self._sites is None or len(self._sites) == 0:\\n return None\\n return self._sites\",\n \"def sites(self):\\n return self.data.sites.values\",\n \"def load_sites(self, site_list: list = None):\\n try:\\n sites = self.api.get(host=self.host, endpoint=f\\\"/api/v1/orgs/{self.oid}/sites\\\")\\n except Exception as e:\\n logger.error(f\\\"{TextColors.FAIL}Error getting org sites:{TextColors.ENDC} {e}\\\")\\n raise e\\n if site_list:\\n sites = [s for s in sites if s['name'] in site_list]\\n self.sites = sites\",\n \"def list_sites(NextToken=None, MaxResults=None):\\n pass\",\n \"def _sites(self):\\n return self.properties.get('sites',\\n SitePropertiesCollection(self.context, ResourcePath(\\\"sites\\\", self.resource_path)))\",\n \"def list_site_data(site_name):\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n\\n sitedoc = {'_id': siteid, 'name': site_name, 'settings': _get_settings(siteid)}\\n\\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\\n querystring = 'select id, dirname from {} where site_id = %s;'.format(TABLES[2])\\n result = execute_query(querystring, (siteid,))\\n dirmap = {row['id']: row['dirname'] for row in result}\\n dirids = [x for x in dirmap]\\n sitedoc['docs'] = {x: {} for x in dirmap.values()}\\n\\n querystring = ('select docname, source_docid, source_updated, source_deleted, target_docid, '\\n 'target_updated, target_deleted, mirror_updated, dir_id from {} '\\n 'where dir_id = any(%s);'.format(TABLES[3]))\\n result = execute_query(querystring, (dirids,))\\n docstats, docnames = [], {}\\n for row in result:\\n doc, dir = row['docname'], dirmap[row['dir_id']]\\n docitem = doc if dir == '/' else '/'.join((dir, doc))\\n ## docstats.append((dir, doc,\\n ## ('src', {'docid': row['source_docid'], 'updated': row['source_updated']}),\\n ## ('dest', {'docid': row['target_docid'], 'updated': row['target_updated']}),\\n ## ('to_mirror', {'updated': row['mirror_updated']})))\\n docdata = [dir, doc]\\n sourcedoc, destdoc = {}, {}\\n if row['source_docid'] is not None:\\n sourcedoc['docid'] = row['source_docid']\\n if row['source_updated'] is not None:\\n sourcedoc['updated'] = row['source_updated']\\n if row['source_deleted'] is not None:\\n sourcedoc['deleted'] = row['source_deleted']\\n if sourcedoc:\\n docdata.append(('src', sourcedoc))\\n if row['target_docid'] is not None:\\n destdoc['docid'] = row['target_docid']\\n if row['target_updated'] is not None:\\n destdoc['updated'] = row['target_updated']\\n if row['target_deleted'] is not None:\\n destdoc['deleted'] = row['target_deleted']\\n if destdoc:\\n docdata.append(('dest', destdoc))\\n if row['mirror_updated'] is not None:\\n docdata.append(('mirror', {'updated': row['target_updated']}))\\n docstats.append(tuple(docdata))\\n docnames[row['source_docid']] = (docitem, 'src')\\n docnames[row['target_docid']] = (docitem, 'dest')\\n\\n for dir, doc, *items in sorted(docstats):\\n sitedoc['docs'][dir][doc] = {x: y for x, y in items}\\n ## if item[0] != olddir:\\n ## if olddir:\\n ## sitedoc['docs'][olddir] = dirdict\\n ## olddir = item[0]\\n ## dirdict = {}\\n ## dirdict[item[1]] = {x:y for x, y in item[2:]}\\n ## if olddir:\\n ## [olddir] = dirdict\\n\\n data = []\\n querystring = 'select id, currtext, previous from {} where id = any(%s)'.format(TABLES[4])\\n result = execute_query(querystring, ([x for x in docnames],))\\n for row in result:\\n data.append({'_id': docnames[row['id']], 'current': row['currtext'],\\n 'previous': row['previous']})\\n\\n querystring = 'select name, text from {} where site_id = %s;'.format(TABLES[5])\\n result = execute_query(querystring, (siteid,))\\n for row in result:\\n data.append({'_id': (row['name'],), 'template contents': row['text']})\\n\\n\\n\\n return sitedoc, sorted(data, key=lambda x: x['_id'])\",\n \"def list_websites(self):\\r\\n\\r\\n # Fetch websites\\r\\n self.fetch_website_list()\\r\\n\\r\\n # Print website data\\r\\n for website in self.website_list:\\r\\n print(\\\"ID: {0} | Domain: {1} | Name: {2}\\\".format(\\r\\n website['id'], website['domain'], website['name']))\",\n \"def sites(self):\\n return self._sites\",\n \"def sites(self):\\n return self._sites\",\n \"def list_sites(keys):\\n key_store = KeyStore(get_config_file())\\n for site, key in key_store.list_sites().iteritems():\\n if keys:\\n click.echo(\\\"{} = {}\\\".format(site, key))\\n else:\\n click.echo(site)\",\n \"def get_docs_urls(self):\\n docs_urls = []\\n link_labels = []\\n for tag in self.post_div.find_all(\\\"a\\\"):\\n url = tag[\\\"href\\\"]\\n if url.startswith(\\\"https://docs.google.com\\\") or \\\\\\n url.startswith(\\\"https://drive.google.com\\\"):\\n docs_urls += [url]\\n link_labels += [tag.text]\\n return docs_urls, link_labels\",\n \"def get_site_list():\\n log = current_app.log\\n db = request.db\\n user_id = SiteService.get_current_uid()\\n Site = db.tables.Site\\n site_list = []\\n sites = Site.query.all()\\n for site_entry in sites:\\n # Ensure user can only see the correct sites\\n is_owner = False\\n is_visible = False\\n if site_entry.site_owner == user_id:\\n is_owner = True\\n is_visible = True\\n elif site_entry.public:\\n is_visible = True\\n if not is_visible:\\n continue\\n # Build the output object\\n cur_site = {\\\"is_owner\\\": is_owner,\\n \\\"public\\\": site_entry.public}\\n for key in (\\\"site_id\\\", \\\"site_name\\\", \\\"site_desc\\\", \\\"def_path\\\"):\\n cur_site[key] = getattr(site_entry, key)\\n site_list.append(cur_site)\\n log.info(\\\"Found %u sites for user id %u.\\\", len(site_list), user_id)\\n return jsonify(site_list)\",\n \"def sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WebChatSiteArgs']]]]:\\n return pulumi.get(self, \\\"sites\\\")\",\n \"def getListOfSites(self):\\n with self.config.TaskWorker.envForCMSWEB:\\n sites = self.resourceCatalog.getAllPSNs()\\n filteredSites = [site for site in sites if not site.startswith(\\\"T1_\\\")]\\n\\n return filteredSites\",\n \"def iter_sites(self):\\n return iter(self.site_list)\",\n \"def get_sites():\\n #sites = sys.argv[1:] # Accept sites from command line input\\n\\n # Read in additional sites to monitor from sites.txt file\\n try:\\n sites = [site.strip() for site in io.open('sites.txt', mode='r').readlines()]\\n except IOError:\\n print (colorize(\\\"No sites.txt file found\\\", \\\"red\\\"))\\n\\n # Add protocol if missing in URL\\n for site in range(len(sites)):\\n if sites[site][:7] != \\\"http://\\\" and sites[site][:8] != \\\"https://\\\":\\n sites[site] = \\\"http://\\\" + sites[site]\\n\\n # Eliminate exact duplicates in sites\\n sites = list(set(sites))\\n\\n return sites\",\n \"def get_sites():\\n results = __gae_fetch('https://api.stackexchange.com/%s/sites?pagesize=999&key=%s' % (__api_version, api_key))\\n response = simplejson.loads(results.content)\\n return response\",\n \"def sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DirectLineSiteArgs']]]]:\\n return pulumi.get(self, \\\"sites\\\")\",\n \"def get_sites():\\n sites_file = open(FILENAME)\\n sites = []\\n for site in sites_file:\\n sites.append(\\\"http://\\\" + site.strip())\\n return sites\",\n \"def get_sites():\\n sites_file = open(FILENAME)\\n sites = []\\n for site in sites_file:\\n sites.append(\\\"http://\\\" + site.strip())\\n return sites\",\n \"def list_domain_names():\\n pass\",\n \"def getSites(self):\\n return self.SelectedSites\",\n \"def get_docs_sources(self):\\n docs = [doc for doc,_,_ in self.doc_to_get]\\n \\n retry_until_ok(self.docman.elastic.indices.refresh, index=\\\"\\\")\\n documents = self.docman.elastic.mget(body={'docs': docs})\\n return documents\",\n \"def getVCDRSites(**kwargs):\\n strVCDRProdURL = kwargs['strVCDRProdURL']\\n sessiontoken = kwargs['sessiontoken']\\n if kwargs['cloud_fs_id'] is None:\\n print(\\\"Please specify the ID of the cloud file system using '-cloud-fs-id'\\\")\\n sys.exit(1)\\n cloud_fs_id = kwargs['cloud_fs_id']\\n if kwargs['site_id'] is None:\\n json_response = get_vcdr_sites_json(strVCDRProdURL, cloud_fs_id, sessiontoken)\\n if json_response == None:\\n print(\\\"API Error\\\")\\n sys.exit(1)\\n sites = json_response[\\\"protected_sites\\\"]\\n table = PrettyTable(['Site Name', 'Site ID'])\\n for i in sites:\\n table.add_row([i['name'], i['id']])\\n print(table)\\n else:\\n site_id = kwargs['site_id']\\n json_response = get_vcdr_site_details_json(strVCDRProdURL, cloud_fs_id, site_id, sessiontoken)\\n if json_response == None:\\n print(\\\"API Error\\\")\\n sys.exit(1)\\n print(\\\" \\\")\\n print(f\\\"Site Name: {json_response['name']}\\\")\\n print(f\\\"Site Type: {json_response['type']}\\\")\\n print(\\\" \\\")\",\n \"def iter_sites(self):\\n if self.default_model:\\n return self.default_model.iter_sites()\\n return iter(list())\",\n \"def dorkScanner():\\n pysearch.PySearch()\\n openfile = open(\\\"sites.txt\\\", 'r')\\n urls = openfile.read()\\n openfile.close()\\n return urls\",\n \"def list_docs(site_name, doctype='', directory='', deleted=False):\\n if not directory:\\n directory = '/'\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n dirid = _get_dir_id(siteid, directory)\\n if dirid is None:\\n raise FileNotFoundError('no_subdir')\\n\\n ## doclist = _get_docs_in_dir(dirid)\\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\\n querystring = ('select docname, source_docid, source_deleted, target_docid, target_deleted, '\\n 'mirror_updated from {} where dir_id = %s;')\\n result = execute_query(querystring.format(TABLES[3]), (dirid,))\\n doclist = []\\n for row in cur:\\n # print(doctype, row['source_docid'], deleted, row['source_deleted'])\\n add = False\\n if doctype in ('', 'src') and row['source_docid']:\\n # print(row['source_deleted'])\\n add = bool(row['source_deleted']) == deleted\\n elif doctype == 'dest' and row['target_docid']:\\n add = bool(row['target_deleted']) == deleted\\n elif doctype == 'mirror' and row['mirror_updated']:\\n add = not deleted\\n if add:\\n doclist.append(row['docname'])\\n\\n return doclist # returns all documents of the given type\",\n \"def getDocsList(self):\\n return self.docs_list\",\n \"def urls(self):\\n return self._list_urls()\",\n \"def urls(self) -> list[str]:\\r\\n ...\",\n \"def fetch_website_list(self):\\r\\n # Clear list\\r\\n self.website_list = []\\r\\n\\r\\n # Open websites overview\\r\\n self.browser.open(self.config[\\\"base_url\\\"] + \\\"websites\\\")\\r\\n\\r\\n # Find table and iterate over rows\\r\\n for table_row in self.browser.get_current_page().select(\\\"table tr\\\"):\\r\\n\\r\\n # Fetch cells\\r\\n cells = table_row.findAll('td')\\r\\n\\r\\n # Iterate over cells\\r\\n if(len(cells) > 0):\\r\\n\\r\\n # Get website ID\\r\\n website_id = table_row['data-id']\\r\\n # Get website name\\r\\n name = cells[1].text.strip()\\r\\n # Get website domain name\\r\\n domain = cells[2].text.strip()\\r\\n\\r\\n # Build website object\\r\\n website = {'id': website_id,\\r\\n 'name': name, 'domain': domain}\\r\\n\\r\\n # Add website object to list\\r\\n self.website_list.append(website)\",\n \"def get_observing_sites(self):\\n pass\",\n \"def get(self):\\n try:\\n sites = Site.query.all()\\n except OperationalError:\\n raise InternalServerError(description='Site table does not exists.')\\n return sites, 200\",\n \"def get_sites():\\n sites = [ x.get('siteid') for x in Schedconfig.objects.values('siteid').distinct() ]\\n locale.setlocale(locale.LC_ALL, '')\\n sites = sorted(sites, key=locale.strxfrm)\\n return sites\",\n \"def _get_sites(web_crawl):\\n site_list = \\\"\\\"\\n if 'primarySite' in web_crawl:\\n site_list = web_crawl['primarySite'] \\n else:\\n # TODO: throw exception, must have primary site\\n pass\\n if 'additionalSites' in web_crawl:\\n for site in web_crawl['additionalSites']:\\n site_list += \\\",\\\" + site\\n return site_list\",\n \"def get_supported_sites(self, all=False):\\n if all:\\n return self.supported_sites.keys()\\n else:\\n return [site_name for (site_name, site) in self.supported_sites.items() if site.enabled]\",\n \"def list_all():\\n\\n return (_conn.listDefinedDomains() +\\n [_conn.lookupByID(id).name() for id in _conn.listDomainsID()])\",\n \"def get_input_domains():\\n df = pandas.read_excel(\\\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\\\", engine=\\\"odf\\\")\\n list_of_addresses = df['Domain'].to_list()\\n list_of_addresses = [(\\\"http://\\\" + address) for address in list_of_addresses]\\n print(list_of_addresses)\\n return list_of_addresses\",\n \"def get_vhosts( self ):\\n self.sites_available = []\\n self.created_RE = re.compile( '#VirtualHost created by localsite.py' )\\n vlogging.ret_logger.debug( 'listing localsites now' )\\n available_dir = '/etc/apache2/sites-available'\\n sites_available = os.listdir( available_dir )\\n vlogging.ret_logger.info( sites_available )\\n sites_enabled = os.listdir( '/etc/apache2/sites-enabled' ) \\n for item in sites_available:\\n file_path = os.path.join( available_dir, item )\\n if os.path.isfile( file_path ):\\n f = open( file_path, 'rb' )\\n # Check to see if the site was created by vhosts.py\\n if self.created_RE.match( f.read( 36 ) ):\\n if item in sites_enabled:\\n enabled = True\\n else:\\n enabled = False\\n vhost = VirtualHost( item, enabled )\\n self.sites_available.append( vhost )\\n f.close()\\n return self.sites_available\",\n \"def GetDocumentListFeed(self):\\n q = gdata.docs.service.DocumentQuery();\\n return self.QueryDocumentListFeed(q.ToUri())\",\n \"def get_all_site_names(_current_parser=None):\\n parser = _get_parser(_current_parser)\\n return [site for site in parser if site != \\\"DEFAULT\\\"]\",\n \"def build_sites_list():\\n ns_getsites_filter = '''\\n <nc:filter type=\\\"xpath\\\"\\n xmlns:nc=\\\"urn:ietf:params:xml:ns:netconf:base:1.0\\\"\\n xmlns:rm=\\\"http://cisco.com/ns/yang/Cisco-IOS-XE-route-map\\\"\\n select=\\\"/native/route-map[substring(name, 1, 3)='To_']/name\\\"\\n />\\n '''\\n m = manager.connect( host='10.112.83.100',\\n port=830,\\n username='cisco',\\n password='cisco',\\n hostkey_verify=False)\\n answer = m.get_config(source='running', filter=ns_getsites_filter).data_xml\\n c = xmltodict.parse (answer)\\n # build the list\\n liste_sites = [ r['name'][3:] for r in c['data']['native']['route-map'] ]\\n return liste_sites\",\n \"def get_site_designs(context, include_untargeted=True, store=None):\\n return_type = ClientResult(context, ClientValueCollection(SiteDesignMetadata))\\n utility = SiteScriptUtility(context)\\n payload = {\\n \\\"includeUntargeted\\\": include_untargeted,\\n \\\"store\\\": store\\n }\\n qry = ServiceOperationQuery(utility, \\\"GetSiteDesigns\\\", None, payload, None, return_type)\\n qry.static = True\\n context.add_query(qry)\\n return return_type\",\n \"def getNSites(self):\\n return self.nsites\",\n \"def get_all(self, search_string: str = None) -> Dict[str, Any]:\\n headers = self._setup_headers_with_sail_json()\\n all_site_resp = self.interactor.get_page(_Sites.TEMPO_SITE_PAGE_NAV, headers=headers, label=\\\"Sites.SiteNames\\\")\\n all_site_json = all_site_resp.json()\\n for site_info in extract_values(all_site_json, '#t', 'SitePageLink'):\\n if 'siteUrlStub' in site_info:\\n site_url_stub = site_info['siteUrlStub']\\n self.get_site_data_by_site_name(site_url_stub)\\n return self._sites\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def build_docs(context, site_name=None, view=True, assume_yes=False):\\n logger.debug(\\\"Starting cli.datasource.build_docs\\\")\\n\\n if site_name is not None:\\n site_names = [site_name]\\n else:\\n site_names = None\\n index_page_locator_infos = context.build_data_docs(\\n site_names=site_names, dry_run=True\\n )\\n\\n msg = \\\"\\\\nThe following Data Docs sites will be built:\\\\n\\\\n\\\"\\n for site_name, index_page_locator_info in index_page_locator_infos.items():\\n msg += \\\" - <cyan>{}:</cyan> \\\".format(site_name)\\n msg += \\\"{}\\\\n\\\".format(index_page_locator_info)\\n\\n cli_message(msg)\\n if not assume_yes:\\n toolkit.confirm_proceed_or_exit()\\n\\n cli_message(\\\"\\\\nBuilding Data Docs...\\\\n\\\")\\n context.build_data_docs(site_names=site_names)\\n\\n cli_message(\\\"Done building Data Docs\\\")\\n\\n if view:\\n context.open_data_docs(site_name=site_name, only_if_exists=True)\",\n \"def get_urls():\\r\\n return []\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('metadata', {}).get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def get_datasource_list():\\n global datasource_list\\n\\n if not datasource_list:\\n datasource_list = stixhelpers.get_datasources(get_srcs())\\n\\n return datasource_list\",\n \"def get_sites(self, filter_term=None):\\n\\n self.logger.debug(\\\"getting sites from Netlify\\\")\\n\\n if Cache.get(self.CACHE_KEY):\\n self.logger.debug(\\\"Loading from cache\\\")\\n return self.filter_sites(Cache.get(self.CACHE_KEY), filter_term)\\n\\n headers = {\\n \\\"Authorization\\\": \\\"Bearer {}\\\".format(\\n self.access_token),\\n \\\"Accept\\\": \\\"application/json\\\",\\n \\\"User-Agent\\\": \\\"Ulauncher-Netlify\\\"}\\n req = requests.get(self.API_BASE_URL + '/sites/', headers=headers)\\n\\n if not req.ok:\\n if req.status_code == 401:\\n raise AuthenticationException(\\n \\\"Failed to authenticate with access token \\\" + self.access_token)\\n\\n raise GenericException(\\n \\\"Error connecting to Netlify API : status \\\" + req.status_code)\\n\\n data = req.json()\\n\\n Cache.set(self.CACHE_KEY, data, self.CACHE_TTL)\\n\\n return self.filter_sites(data, filter_term)\",\n \"def _find_sites_for_user(email):\\n sitez = set()\\n for g in groups.find({\\\"users\\\":email}):\\n for s in g['sites']:\\n sitez.add(s)\\n return list(sitez)\",\n \"def getURLs():\",\n \"def getSitesData( self ):\\n if self.lastDataRetrievalTime - time.time() < 300:\\n result = self.__getRPCClient().getSitesData()\\n if 'rpcStub' in result:\\n del( result[ 'rpcStub' ] )\\n if not result[ 'OK' ]:\\n return result\\n self.sitesData = result[ 'Value' ]\\n if self.sitesData:\\n self.lastDataRetrievalTime = time.time()\\n return S_OK( self.sitesData )\",\n \"def api_list(self):\\n return self._get('apis')\",\n \"def getUrlsList(self):\\n\\t\\ttry:\\n\\t\\t\\tf = ur.urlopen(self.sitemap_url)\\n\\t\\t\\tres = f.readlines()\\n\\t\\t\\tfor d in res:\\n\\t\\t\\t data = re.findall('<loc>(https?:\\\\/\\\\/.+?)<\\\\/loc>',d)\\n\\t\\t\\t for i in data:\\n\\t\\t\\t\\tself.urls.append(i)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tself.app.printflush(str(e))\\n\\t\\t\\tself.app.printflush(traceback.format_exc())\\n\\t\\tself.fetched_count = len(self.urls)\",\n \"def sites(self) -> Sequence[LatticeSite]:\\n return self._sites\",\n \"def search(url, domain_list):\\n resp = requests.get(url)\\n if not resp.json().get('hits', '').get('hits', []):\\n return\\n for hit in resp.json()[\\\"hits\\\"][\\\"hits\\\"]:\\n domain = hit.get(\\\"_source\\\", {}).get(\\\"domain\\\", \\\"\\\")\\n if not domain:\\n continue\\n if not domain in domain_list:\\n domain_list.append(domain)\\n #print(hit[\\\"_source\\\"].get(\\\"title\\\", \\\"\\\").encode(\\\"ascii\\\",\\\"ignore\\\"))\\n if domain not in ALLOWED_DOMAINS:\\n print(domain)\",\n \"def get_indexes(self):\\n resources = []\\n\\n data = self.get_resource_data(type='sources')\\n data['url'] = constants.URLS['sources'] % data\\n resources.append(data)\\n\\n for arch in self.data['arch']:\\n data = self.get_resource_data(type='packages', arch=arch)\\n data['url'] = constants.URLS['packages'] % data\\n resources.append(data)\\n return resources\",\n \"def urls(self) -> str:\\n return self._data['urls']\",\n \"def urls(self):\\n days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', ]\\n url = 'http://www2.nngov.com/newport-news/offenses/%stxt.htm'\\n return [url % day for day in days]\",\n \"def list_dirs(site_name, doctype=''):\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n\\n ## probable inefficient approach\\n ## for dir_id in dirids:\\n ## docs = _get_docs_in_dir(dir_id)\\n ## for docname in docs:\\n ## docids = _get_doc_ids(dir_id, docname)\\n ## if docids[1] is not None:\\n ## diridlist.append(dir_id)\\n querystring = 'select id, dirname from {} where site_id = %s;'\\n result = execute_query(querystring.format(TABLES[2]), (siteid,))\\n dirmap = {row['id']: row['dirname'] for row in result}\\n dirids = [x for x in dirmap]\\n if doctype in ('', 'src'):\\n pass\\n elif doctype == 'dest':\\n querystring = 'select dir_id, target_docid from {} where dir_id = any(%s);'\\n result = execute_query(querystring.format(TABLES[3]), (dirids,))\\n dirids = set()\\n for row in result:\\n if row['target_docid'] is not None:\\n dirids.add(row['dir_id'])\\n else:\\n raise RuntimeError('wrong doctype for list_dirs')\\n dirlist = []\\n for id in dirids:\\n test = dirmap[id]\\n if test != '/':\\n dirlist.append(test)\\n return dirlist # returns all dirs that have documents of the given type\",\n \"def getDocuments(self):\\n documents = []\\n\\n for document in self.metaData.jsonObj['documents']:\\n d = HyperLinkResource(document)\\n documents.append(Document(self._client, d.selfLink))\\n\\n return documents\",\n \"def list_domain_names(self) -> Dict:\\n pass\",\n \"def start_urls(self):\\n if self.agency_doc_id or self.dept_doc_id:\\n agency_doc_id = self.agency_doc_id\\n if isinstance(agency_doc_id, list):\\n agency_doc_id = agency_doc_id[0]\\n return [\\n \\\"https://detroitmi.gov/documents?{}={}&{}={}\\\".format(\\n self.doc_query_param_dept,\\n self.dept_doc_id,\\n self.doc_query_param,\\n agency_doc_id or \\\"\\\",\\n )\\n ]\\n else:\\n return [self.get_event_start_url()]\",\n \"def GetSlavesForHost():\\n hostname = os.getenv('TESTING_SLAVENAME')\\n if not hostname:\\n hostname = socket.getfqdn().split('.', 1)[0].lower()\\n return [s for s in GetAllSlaves() if s.get('hostname') == hostname]\",\n \"def get_all_doc_stats(site_name):\\n siteid = _get_site_id(site_name)\\n if siteid is None:\\n raise FileNotFoundError('no_site')\\n\\n dirids = _get_all_dir_ids(siteid)\\n cur = conn.cursor(cursor_factory=pgx.RealDictCursor)\\n querystring = 'select dirname from {} where site_id = %s;'.format(TABLES[2])\\n result = execute_query(querystring, (siteid,))\\n dirnames = [row['dirname'] for row in result]\\n querystring = ('select dirname, docname, source_updated, target_updated, mirror_updated,'\\n ' source_deleted, target_deleted from {0}, {1} where dir_id = {1}.id'\\n ' and dir_id = any(%s);'.format(TABLES[3], TABLES[2]))\\n result = execute_query(querystring, (dirids,))\\n all_stats = [(row['dirname'],\\n row['docname'],\\n _get_stats((row['source_updated'], row['target_updated'], row['mirror_updated'])))\\n for row in result if not any((row['source_deleted'], row['target_deleted']))]\\n\\n stats_list = []\\n for name in sorted(dirnames):\\n cp = functools.partial(_is_equal, y=name)\\n dirlist = filter(cp, all_stats) # Pylint: using a list comprehension can be clearer?\\n stats_list.append((name, [x[1:] for x in dirlist]))\\n\\n return stats_list\",\n \"def fetch_list(self):\\n\\t\\treturn self.fetch(self.list_url % ART_SERVER_HOST)\",\n \"def list_pd(cls, pss_url):\\n pds_url = cls.__get_url(pds_url)\\n logger.debug(\\\"List PDS at %s\\\"%pds_url)\\n pds_dir = saga.advert.directory(pds_url, saga.advert.Create | \\n saga.advert.CreateParents | \\n saga.advert.ReadWrite)\\n \\n pd_list = pds_dir.list()\\n pd_full_urls = []\\n for i in pd_list:\\n pd_full_urls.append(pss_url + \\\"/\\\" + i) \\n return pd_full_urls\",\n \"def relevant_domains(self):\\n pass\",\n \"def get_org_list():\\r\\n\\r\\n resp = requests.get(''.join([Kegg.BASE_URL, 'list/organism']))\\r\\n return resp.text\",\n \"def sites(self):\\n struc = self.structure\\n pots = self.potentials\\n shapes = self.shapes\\n\\n _, new_pots = self._check_for_CPA(struc, pots)\\n site_list = []\\n for j in range(len(struc.sites)):\\n site_list.append({\\n 'StructureDataSite': struc.sites[j],\\n 'potential': new_pots[j],\\n 'shapefun': shapes[j % len(shapes)]\\n })\\n return site_list\",\n \"def getListOfSDs(name = None,selector = None):\\n sds = rhevGet(\\\"/api/datacenters/%s/storagedomains\\\"%getDcData(rhev_settings.DC,\\\"id\\\"))\\n doc = libxml2.parseDoc(sds)\\n ctxt = doc.xpathNewContext()\\n res = ctxt.xpathEval(\\\"/storage_domains/storage_domain\\\")\\n sdlist = []\\n for sd in res:\\n sdin = {}\\n sdin[\\\"name\\\"] = sd.firstElementChild().get_content()\\n sdin[\\\"id\\\"] = sd.prop(\\\"id\\\")\\n sdlist.append(sdin)\\n result = []\\n if name:\\n result = [sdin for sdin in sdlist if sdin[\\\"name\\\"].find(name) != -1]\\n return result or sdlist\",\n \"def get_site_feeds(url):\\n url: str = remove_subdomains(url)\\n\\n site: SiteHost = db_client.query_site_feeds(url)\\n\\n if site:\\n try:\\n site_schema = ExternalSiteSchema()\\n result = site_schema.dump(site)\\n except ValidationError as err:\\n app.logger.warning(\\\"Dump errors: %s\\\", err.messages)\\n return abort(500)\\n\\n return jsonify(result)\\n else:\\n response = jsonify({\\\"message\\\": f\\\"No feed information saved for url {url}\\\"})\\n response.status_code = 402\\n return response\",\n \"def show_list():\\n\\n response = []\\n docs = SUPERHEROES.stream()\\n for doc in docs:\\n response.append(doc.to_dict())\\n return jsonify(response), 201\",\n \"def list_domain(self, feed_id=None):\\n resources = self.list_resource(feed_id=feed_id, resource_type_id='Host Controller')\\n domains = []\\n if resources:\\n for resource in resources:\\n resource_data = self.get_config_data(\\n feed_id=resource.path.feed_id, resource_id=resource.id)\\n domain_data = resource_data.value\\n domains.append(Domain(resource.id, resource.name, resource.path, domain_data))\\n return domains\",\n \"def _gather_data(dirpath: str, visible_sites: List[str] = None) -> Dict[str, List[Dict[str, Any]]]:\\n parser = html5lib.HTMLParser(strict=True)\\n\\n results = []\\n for path in os.walk(dirpath):\\n site = path[0].rsplit(\\\"/\\\", 1)[1]\\n if visible_sites and site not in visible_sites and site != \\\"global\\\":\\n continue\\n with open(os.path.join(dirpath, site, \\\"site.json\\\"), \\\"r\\\") as f:\\n entity = json.loads(f.read())\\n if site != \\\"global\\\":\\n try:\\n Site(**entity)\\n except ValidationError as e:\\n print(f\\\"Error processing site.json for {site}: {e.json()}\\\")\\n raise e\\n with open(os.path.join(dirpath, site, \\\"summary.html\\\"), \\\"r\\\") as f:\\n summary = f.read()\\n parser.parseFragment(summary)\\n entity[\\\"summary\\\"] = summary\\n results.append(entity) \\n return {\\\"sites\\\" : results }\",\n \"def get_urls(db):\\n return db.meta.find_one({'name':\\\"urls\\\"})['urls']\",\n \"def domains(self):\\n return DomainCollection(self.request)\",\n \"def list_servers(self, all_tenants=False):\\n _url = \\\"http://\\\" + self.host_ip + \\\":8774/v2/\\\" + \\\\\\n self.project_info[\\\"project_id\\\"] + \\\"/servers/detail\\\"\\n if all_tenants:\\n _url = \\\"http://\\\" + self.host_ip + \\\":8774/v2/\\\" + self.project_info[\\n \\\"project_id\\\"] + \\\"/servers/detail?all_tenants=1\\\"\\n _headers = {'x-auth-token': self.project_info[\\\"token_project\\\"],\\n 'content-type': 'application/json'}\\n _body = None\\n response = self.request(\\\"GET\\\", _url, _headers, _body)\\n if response is None:\\n LOG_OBJ.error(\\\"No response from server while listing servers.\\\")\\n return\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\\"List servers Failed with status %s \\\" %\\n response.status)\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"Servers List :%s \\\" % output)\\n return output[\\\"servers\\\"]\",\n \"def list_domain(self, feed_id=None):\\n domains = self.list_resource(feed_id=feed_id,\\n resource_type_id='Domain Host',\\n cls=Domain,\\n list_children=True,\\n include_data=True)\\n return domains\",\n \"def get_local_schedds(schedd_base_name=socket.getfqdn()):\\n schedd_list = []\\n temp_list = htcondor.Collector().locateAll(htcondor.DaemonTypes.Schedd)\\n for schedd in temp_list:\\n if 'Name' not in schedd:\\n continue\\n if schedd_base_name in schedd['Name']:\\n schedd_list.append(schedd)\\n return schedd_list\",\n \"def domains(cls):\\n return [cls.domain]\",\n \"def hosts(self) -> t.List[str]:\\n if not self._hosts:\\n self._hosts = self._get_db_hosts()\\n return self._hosts\",\n \"def getPublicEMPDownloadLinks(self):\\n try:\\n studies = []\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('get_public_emp_studies', [results])\\n for row in results:\\n # study_id, project_name, file_path, study_abstract\\n studies.append((row[0], row[1], row[2], row[3]))\\n return studies\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\",\n \"def get_downloadable_data(url_list):\\n downloadable_data_list = []\\n for url in url_list:\\n soup = visit_homepage(url)\\n for link in soup.find_all(class_='resource-url-analytics'):\\n downloadable_data_list.append(link['href'])\\n return downloadable_data_list\",\n \"def tracking_domain_list(self):\\r\\n params = base.get_params(None, locals())\\r\\n return self._get('tracking_domain_list', params)\",\n \"def listaServicios(self):\\n portal_catalog = getToolByName(self, 'portal_catalog')\\n mt = portal_catalog.searchResults(portal_type = 'ServeiTIC',\\n path={\\\"query\\\": '/'.join(self.getParentNode().getParentNode().getPhysicalPath()),\\\"depth\\\":2},\\n sort_on='Date')\\n new_list=[]\\n for f in mt:\\n new_list.append(f.Title)\\n new_list.sort()\\n return new_list\",\n \"def allSites(self, expandSeries=True):\\n for siteNames in self._typeDict.values():\\n for name in siteNames:\\n site = getattr(self, name)\\n if isinstance(site, IconSiteSeries):\\n if expandSeries:\\n for s in site.sites:\\n yield s\\n else:\\n yield site\\n elif isinstance(site, IconSite):\\n yield site\",\n \"def listsources():\\n\\tmain_url = \\\" https://newsapi.org/v2/sources?apiKey=5f81b593f35d42a8980313250c03d7e7\\\"\\n\\n\\t# fetching data in json format \\n\\topen_source = requests.get(main_url).json() \\n\\n\\t# getting all articles in a string sources\\n\\tsource = open_source[\\\"sources\\\"] \\n\\n\\t# empty list which will \\n\\t# contain all trending newssources \\n\\tresults = [] \\n\\t\\n\\tfor k in source: \\n results.append(k[\\\"id\\\"])\\n \\n \\t\\n\\tfor w in results[0:4]:\\n print(w)\",\n \"def list(self):\\n\\t\\treturn self.link_words\",\n \"def importSites(self,sites_list):\\n \\\"\\\"\\\" Append these sites objects to a sample \\\"\\\"\\\" \\n self.sites = []\\n for s in sites_list:\\n mySite = Site(s)\\n self._addSite(mySite)\",\n \"def get_website_URLs():\\n\\tfilepath = os.path.dirname(os.path.realpath(__file__)) +\\\"/web_sources\\\"\\n\\tf = open(filepath, 'r')\\n\\twebsites = []\\n\\tfor line in f:\\n\\t\\tif line != \\\"\\\\n\\\":\\n\\t\\t\\tendl_index = line.index('\\\\n')\\n\\t\\t\\tclean_line = line[:endl_index]\\n\\t\\t\\tnew_list = clean_line.split(' ', 1)\\n\\t\\t\\twebsites.append(new_list)\\n\\tf.close()\\n\\treturn websites\",\n \"def company_lists(self):\\n return self.client.get('company/named-lists')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68871546","0.6885869","0.66649675","0.6592278","0.6572376","0.6511911","0.65085405","0.6494182","0.6483239","0.64800274","0.6446842","0.64075714","0.63722503","0.63695705","0.63695705","0.62545717","0.6170089","0.61219245","0.60714644","0.6027309","0.5988352","0.59696364","0.5955322","0.5948048","0.5940118","0.5940118","0.59204423","0.58621603","0.5850811","0.5837448","0.5795868","0.57829744","0.577872","0.57274103","0.5720449","0.56850785","0.56795883","0.5671918","0.5664521","0.5655312","0.5631235","0.55992454","0.55979186","0.5586958","0.5572894","0.5553583","0.55501384","0.55251646","0.5519159","0.5461907","0.54617137","0.54580516","0.5443896","0.5424901","0.54243284","0.5416388","0.5399565","0.5394182","0.538102","0.5370248","0.53479445","0.53436077","0.5323158","0.53116876","0.5308379","0.53080165","0.53007215","0.5298749","0.52717745","0.52711564","0.52615494","0.5260946","0.5256935","0.52484727","0.52462417","0.52430683","0.52404934","0.52375245","0.52350533","0.52204394","0.5214596","0.52120274","0.5203857","0.5199461","0.51877606","0.5182144","0.51731044","0.5173046","0.5172879","0.51696885","0.5169108","0.5165118","0.5158668","0.5153838","0.5153314","0.51457477","0.51345307","0.5128427","0.5128403","0.512756"],"string":"[\n \"0.68871546\",\n \"0.6885869\",\n \"0.66649675\",\n \"0.6592278\",\n \"0.6572376\",\n \"0.6511911\",\n \"0.65085405\",\n \"0.6494182\",\n \"0.6483239\",\n \"0.64800274\",\n \"0.6446842\",\n \"0.64075714\",\n \"0.63722503\",\n \"0.63695705\",\n \"0.63695705\",\n \"0.62545717\",\n \"0.6170089\",\n \"0.61219245\",\n \"0.60714644\",\n \"0.6027309\",\n \"0.5988352\",\n \"0.59696364\",\n \"0.5955322\",\n \"0.5948048\",\n \"0.5940118\",\n \"0.5940118\",\n \"0.59204423\",\n \"0.58621603\",\n \"0.5850811\",\n \"0.5837448\",\n \"0.5795868\",\n \"0.57829744\",\n \"0.577872\",\n \"0.57274103\",\n \"0.5720449\",\n \"0.56850785\",\n \"0.56795883\",\n \"0.5671918\",\n \"0.5664521\",\n \"0.5655312\",\n \"0.5631235\",\n \"0.55992454\",\n \"0.55979186\",\n \"0.5586958\",\n \"0.5572894\",\n \"0.5553583\",\n \"0.55501384\",\n \"0.55251646\",\n \"0.5519159\",\n \"0.5461907\",\n \"0.54617137\",\n \"0.54580516\",\n \"0.5443896\",\n \"0.5424901\",\n \"0.54243284\",\n \"0.5416388\",\n \"0.5399565\",\n \"0.5394182\",\n \"0.538102\",\n \"0.5370248\",\n \"0.53479445\",\n \"0.53436077\",\n \"0.5323158\",\n \"0.53116876\",\n \"0.5308379\",\n \"0.53080165\",\n \"0.53007215\",\n \"0.5298749\",\n \"0.52717745\",\n \"0.52711564\",\n \"0.52615494\",\n \"0.5260946\",\n \"0.5256935\",\n \"0.52484727\",\n \"0.52462417\",\n \"0.52430683\",\n \"0.52404934\",\n \"0.52375245\",\n \"0.52350533\",\n \"0.52204394\",\n \"0.5214596\",\n \"0.52120274\",\n \"0.5203857\",\n \"0.5199461\",\n \"0.51877606\",\n \"0.5182144\",\n \"0.51731044\",\n \"0.5173046\",\n \"0.5172879\",\n \"0.51696885\",\n \"0.5169108\",\n \"0.5165118\",\n \"0.5158668\",\n \"0.5153838\",\n \"0.5153314\",\n \"0.51457477\",\n \"0.51345307\",\n \"0.5128427\",\n \"0.5128403\",\n \"0.512756\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6646616"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9459,"cells":{"query":{"kind":"string","value":"Build documentation in a context"},"document":{"kind":"string","value":"def build_docs(context, site_name=None, view=True, assume_yes=False):\n logger.debug(\"Starting cli.datasource.build_docs\")\n\n if site_name is not None:\n site_names = [site_name]\n else:\n site_names = None\n index_page_locator_infos = context.build_data_docs(\n site_names=site_names, dry_run=True\n )\n\n msg = \"\\nThe following Data Docs sites will be built:\\n\\n\"\n for site_name, index_page_locator_info in index_page_locator_infos.items():\n msg += \" - <cyan>{}:</cyan> \".format(site_name)\n msg += \"{}\\n\".format(index_page_locator_info)\n\n cli_message(msg)\n if not assume_yes:\n toolkit.confirm_proceed_or_exit()\n\n cli_message(\"\\nBuilding Data Docs...\\n\")\n context.build_data_docs(site_names=site_names)\n\n cli_message(\"Done building Data Docs\")\n\n if view:\n context.open_data_docs(site_name=site_name, only_if_exists=True)"},"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 sphinxify(docstring, context, buildername='html'):\n\n srcdir = mkdtemp()\n srcdir = encoding.to_unicode_from_fs(srcdir)\n\n base_name = osp.join(srcdir, 'docstring')\n rst_name = base_name + '.rst'\n\n if buildername == 'html':\n suffix = '.html'\n else:\n suffix = '.txt'\n output_name = base_name + suffix\n\n # This is needed so users can type \\\\ on latex eqnarray envs inside raw\n # docstrings\n if context['right_sphinx_version'] and context['math_on']:\n docstring = docstring.replace('\\\\\\\\', '\\\\\\\\\\\\\\\\')\n \n # Add a class to several characters on the argspec. This way we can\n # highlight them using css, in a similar way to what IPython does.\n argspec = context['argspec']\n for char in ['=', ',', '(', ')', '*', '**']:\n argspec = argspec.replace(char,\n '<span class=\"argspec-highlight\">' + char + '</span>')\n context['argspec'] = argspec\n\n doc_file = codecs.open(rst_name, 'w', encoding='utf-8')\n doc_file.write(docstring)\n doc_file.close()\n \n temp_confdir = False\n if temp_confdir:\n # TODO: This may be inefficient. Find a faster way to do it.\n confdir = mkdtemp()\n confdir = encoding.to_unicode_from_fs(confdir)\n generate_configuration(confdir)\n else:\n confdir = osp.join(get_module_source_path('spyderlib.utils.inspector'))\n\n confoverrides = {'html_context': context}\n\n doctreedir = osp.join(srcdir, 'doctrees')\n\n sphinx_app = Sphinx(srcdir, confdir, srcdir, doctreedir, buildername,\n confoverrides, status=None, warning=None,\n freshenv=True, warningiserror=False, tags=None)\n try:\n sphinx_app.build(None, [rst_name])\n except SystemMessage:\n output = _(\"It was not possible to generate rich text help for this \"\n \"object.</br>\"\n \"Please see it in plain text.\")\n return warning(output)\n\n # TODO: Investigate if this is necessary/important for us\n if osp.exists(output_name):\n output = codecs.open(output_name, 'r', encoding='utf-8').read()\n output = output.replace('<pre>', '<pre class=\"literal-block\">')\n else:\n output = _(\"It was not possible to generate rich text help for this \"\n \"object.</br>\"\n \"Please see it in plain text.\")\n return warning(output)\n\n if temp_confdir:\n shutil.rmtree(confdir, ignore_errors=True)\n shutil.rmtree(srcdir, ignore_errors=True)\n\n return output","def generate_documentation(self):\n self.generate_api_docs()\n build.main([\n self.SOURCE_DIR,\n self.BUILD_DIR,\n ])","def buildDocumentation():\n helptext = 'usage: build_doc.py <output format> <type of documentation>' \\\n '\\n - html: for html output' \\\n '\\n - pdf: for pdf output' \\\n '\\n\\n - all: complete documentation' \\\n '\\n - dev: only developer documentation' \\\n '\\n - user: only user documentation'\n if len(sys.argv) != 3:\n print helptext\n sys.exit(1)\n\n if sys.argv[1] not in ['pdf', 'html']:\n print helptext\n sys.exit(1)\n if sys.argv[2] not in ['all', 'dev', 'user']:\n print helptext\n sys.exit(1)\n\n copyfile('docs/index_%s.rst.template' % sys.argv[2], 'index.rst') # copy main file into root directory\n os.system('sphinx-build -b %s -c docs -D master_doc=index . docs/output/%s/%s' % (sys.argv[1], sys.argv[1], sys.argv[2]))\n os.remove('index.rst') # delete config file from root directory","def sphinxify(docstring, context, buildername='html', img_path=''):\n if img_path:\n if os.name == 'nt':\n img_path = img_path.replace('\\\\', '/')\n leading = '/' if os.name.startswith('posix') else ''\n docstring = docstring.replace('_images', leading+img_path)\n\n srcdir = osp.join(DOCDIR, '_sources')\n if not osp.exists(srcdir):\n os.makedirs(srcdir)\n base_name = osp.join(srcdir, xrtQookPageName)\n rst_name = base_name + '.rst'\n\n # This is needed so users can type \\\\ on latex eqnarray envs inside raw\n # docstrings\n docstring = docstring.replace('\\\\\\\\', '\\\\\\\\\\\\\\\\')\n\n # Add a class to several characters on the argspec. This way we can\n # highlight them using css, in a similar way to what IPython does.\n # NOTE: Before doing this, we escape common html chars so that they\n # don't interfere with the rest of html present in the page\n argspec = escape(context['argspec'])\n for char in ['=', ',', '(', ')', '*', '**']:\n argspec = argspec.replace(\n char, '<span class=\"argspec-highlight\">' + char + '</span>')\n context['argspec'] = argspec\n\n doc_file = codecs.open(rst_name, 'w', encoding='utf-8')\n doc_file.write(docstring)\n doc_file.close()\n\n confoverrides = {'html_context': context,\n 'extensions': ['sphinx.ext.mathjax',\n 'sphinxcontrib.jquery']}\n\n doctreedir = osp.join(DOCDIR, 'doctrees')\n sphinx_app = Sphinx(srcdir, DOCDIR, DOCDIR, doctreedir, buildername,\n confoverrides, status=None, warning=None,\n freshenv=True, warningiserror=False, tags=None)\n\n try:\n sphinx_app.build(None, [rst_name])\n except SystemMessage:\n pass","def documentation():\n return render_template('help.html')","def build(\n ctx,\n skip,\n enable_doxygen_conf,\n enable_doxygen,\n enable_symlinks,\n enable_sphinx,\n use_doxygen_conf_in,\n doxygen_conf_defaults_path,\n dox,\n skip_dox,\n warning_is_error,\n nitpicky,\n):\n root_project_dir = discover_conf_py_directory(ctx.obj[\"root_project_dir\"])\n\n if doxygen_conf_defaults_path is not None:\n _doxygen_conf_defaults_path = Path(doxygen_conf_defaults_path)\n else:\n _doxygen_conf_defaults_path = None\n\n return_code = build_stack_docs(\n root_project_dir,\n skipped_names=skip,\n prefer_doxygen_conf_in=use_doxygen_conf_in,\n doxygen_conf_defaults_path=_doxygen_conf_defaults_path,\n enable_doxygen_conf=enable_doxygen_conf,\n enable_doxygen=enable_doxygen,\n enable_package_links=enable_symlinks,\n enable_sphinx=enable_sphinx,\n select_doxygen_packages=dox,\n skip_doxygen_packages=skip_dox,\n warning_is_error=warning_is_error,\n nitpicky=nitpicky,\n )\n if return_code > 0:\n sys.exit(return_code)","def doc(self):\n from distutils.dir_util import copy_tree\n\n def copy_tree_checker(src, dst):\n \"\"\"Wrap copy_tree to avoid pydoit error.\"\"\"\n copy_tree(src, dst)\n return True\n\n return {\n \"actions\": [\n (create_dir, [\"build/doc/source\"]),\n (copy_tree_checker, [\"docs\", \"build/doc/source\"]),\n TaskCreator.get_sphinx() + \"-apidoc -o build/doc/source --force --separate --module-first \" + self.project_name_sc,\n TaskCreator.get_sphinx() + \"-build -j auto -n build/doc/source build/doc/html\"\n ],\n \"verbosity\": 2\n }","def beehive_make_doc(self):\n run_data = {\n u'tags':[u'doc'],\n u'local_package_path':self.local_package_path\n } \n self.ansible_playbook(u'docs', run_data, \n playbook=self.beehive_doc_playbook)","def docs():\n sh('sphinx-build -W -b html docs docs/_build/html')","def get_documentation(self, *args, **dargs):\n pass","def build_docs(source, destination, doctrees):\n sphinx_argv = [\n '-b', 'html',\n '-d', doctrees,\n source,\n destination]\n\n sphinx_main(['sphinx-build'] + sphinx_argv)","def generate_context(name='', argspec='', note='', math=False, collapse=False,\n img_path=''):\n \n context = \\\n {\n # Arg dependent variables\n 'math_on': 'true' if math else '',\n 'name': name,\n 'argspec': argspec,\n 'note': note,\n 'collapse': collapse,\n 'img_path': img_path,\n \n # Static variables\n 'css_path': CSS_PATH,\n 'js_path': JS_PATH,\n 'jquery_path': JQUERY_PATH,\n 'mathjax_path': MATHJAX_PATH,\n 'right_sphinx_version': '' if sphinx.__version__ < \"1.1\" else 'true',\n 'platform': sys.platform\n }\n \n return context","def main():\n # We know that qidoc build will set the correct cwd\n qibuild_dir = \"..\"\n qibuild_dir = os.path.abspath(qibuild_dir)\n this_file = __file__\n this_dir = os.path.dirname(this_file)\n cmake_api = os.path.join(this_dir, \"../source/advanced/cmake/api\")\n cmake_api = os.path.abspath(cmake_api)\n if not os.path.exists(cmake_api):\n os.makedirs(cmake_api)\n qibuild_cmake = os.path.join(qibuild_dir, \"cmake\", \"qibuild\")\n for filename in DOCUMENTED_FILES:\n cmake_file = os.path.join(qibuild_cmake, filename + \".cmake\")\n rst_file = os.path.join(cmake_api, filename + \".rst\")\n gen_cmake_doc(cmake_file, rst_file)","def docs():","def with_docs(self):\r\n self._configurations.append('javadoc')\r\n return self","def build_docs(session):\n envbindir = session.bin\n session.install(\"-e\", \".[all,docs]\")\n with session.chdir(\"docs/\"):\n session.run(\n \"sphinx-autobuild\",\n \"-j\",\n \"auto\",\n \"--open-browser\",\n \"-qT\",\n \".\",\n f\"{envbindir}/../tmp/html\",\n )","def test_doc():\n pass","def docs(command, warn_is_error=False, options=\"\"):\n print(\n \"\"\"\nRunning Sphinx to test the docs building\n========================================\n\"\"\"\n )\n o = \"-W \" if warn_is_error else \"\"\n if \"-W\" in options:\n options = options.replace(\"-W\", \"\")\n options = options + \" \" + o\n shutil.rmtree(\"docs/_build\", ignore_errors=True)\n shutil.rmtree(\"docs/api\", ignore_errors=True)\n shutil.rmtree(\"docs/code_reference/api\", ignore_errors=True)\n shutil.rmtree(\"docs/jupyter_execute\", ignore_errors=True)\n shutil.rmtree(\"docs/examples/default_config.yaml\", ignore_errors=True)\n command.run(\"python -m boa.config --output-path docs/examples/default_config.yaml\", echo=True, pty=POSIX)\n command.run(f\"sphinx-build {options} -b html docs docs/_build\", echo=True, pty=POSIX)","def main_docstring():","def build_docs(options):\r\n verbose = getattr(options, 'verbose', False)\r\n\r\n cmd = \"cd {dir}; make html quiet={quiet}\".format(\r\n dir=doc_path(options),\r\n quiet=\"false\" if verbose else \"true\"\r\n )\r\n\r\n sh(cmd)","def documentation():\n return auto.html()","def main(*, build, subdir, description, supports_modules=False,\n supports_quick=False):\n parser = argparse.ArgumentParser(description=description)\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\n \"--serve\", action='store_true',\n help=\"Serve the documentation on the given PORT for easy preview.\")\n group.add_argument(\n \"--out_dir\", type=str, metavar=\"DIR\",\n help=\"Generate the documentation to the given output directory.\"\n \" The DIR must be an absolute path.\"\n \" If DIR already exists, then it must be empty.\"\n \" (For regression testing, the DIR can be the magic value <test>,\"\n \" in which case a $TEST_TMPDIR subdir will be used.)\")\n parser.add_argument(\n \"--port\", type=int, metavar=\"PORT\", default=8000,\n help=\"Use a non-default PORT when serving for preview.\")\n parser.add_argument(\n \"--verbose\", action=\"store_true\",\n help=\"Echo detailed commands, progress, etc. to the console\")\n if supports_modules:\n parser.add_argument(\n \"module\", nargs=\"*\",\n help=\"Limit the generated documentation to only these modules and \"\n \"their children. When none are provided, all will be generated. \"\n \"For example, specify drake.math or drake/math for the C++ \"\n \"module, or pydrake.math or pydrake/math for the Python module.\")\n if supports_quick:\n parser.add_argument(\n \"--quick\", action=\"store_true\", default=False,\n help=\"Omit from the output items that are slow to generate. \"\n \"This yields a faster preview, but the output will be incomplete.\")\n args = parser.parse_args()\n if args.verbose:\n global _verbose\n _verbose = True\n curried_build = build\n if supports_modules:\n canonicalized_modules = [\n x.replace('/', '.')\n for x in args.module\n ]\n curried_build = functools.partial(\n curried_build, modules=canonicalized_modules)\n if supports_quick:\n curried_build = functools.partial(\n curried_build, quick=args.quick)\n if args.out_dir is None:\n assert args.serve\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\n else:\n _do_generate(build=curried_build, out_dir=args.out_dir,\n on_error=parser.error)","def test_html_documentation(self):\n app = Sphinx(\n self.source_dir,\n self.config_dir,\n self.output_dir,\n self.doctree_dir,\n buildername='html',\n warningiserror=True,\n )\n app.build(force_all=self.all_files)","def _sphinx_build(self, kind: str):\n if kind not in (\"html\", \"latex\"):\n raise ValueError(f\"kind must be html or latex, not {kind}\")\n\n cmd = [\"sphinx-build\", \"-b\", kind]\n if self.num_jobs:\n cmd += [\"-j\", self.num_jobs]\n if self.warnings_are_errors:\n cmd += [\"-W\", \"--keep-going\"]\n if self.verbosity:\n cmd.append(f\"-{'v' * self.verbosity}\")\n cmd += [\n \"-d\",\n os.path.join(BUILD_PATH, \"doctrees\"),\n SOURCE_PATH,\n os.path.join(BUILD_PATH, kind),\n ]\n return subprocess.call(cmd)","def _sphinx_build(self, kind: str):\n if kind not in (\"html\", \"latex\"):\n raise ValueError(f\"kind must be html or latex, not {kind}\")\n\n cmd = [\"sphinx-build\", \"-b\", kind]\n if self.num_jobs:\n cmd += [\"-j\", self.num_jobs]\n if self.warnings_are_errors:\n cmd += [\"-W\", \"--keep-going\"]\n if self.verbosity:\n cmd.append(f\"-{'v' * self.verbosity}\")\n cmd += [\n \"-d\",\n os.path.join(BUILD_PATH, \"doctrees\"),\n SOURCE_PATH,\n os.path.join(BUILD_PATH, kind),\n ]\n return subprocess.call(cmd)","def apiDocs():\n\treturn render_template('apiDocs.html')","def run():\n build_no_documentation()\n build_sphinx_build()\n #build_sphinx_pdf()\n build_graphviz_files()","def to_markdown_with_context(context: Context, docstring: str) -> str:\n module: pdoc.doc.Module = context[\"module\"]\n docformat: str = context[\"docformat\"]\n return to_markdown(docstring, module, docformat)","def docs(session):\n session.install('-rrequirements-dev.txt')\n session.install('-e', '.')\n run_sphinx(session)","def generate(self, object=None, replacements=None, source=None):\n\n if replacements is None:\n replacements = []\n\n if source:\n doc_info = source\n else:\n docstring = object.__doc__\n if docstring is None:\n docstring = 'Not yet documented'\n\n doc_info = self.helpers.extract_info(docstring)\n # print(8, docstring)\n # print(6, source, bool(source))\n\n try:\n k = list(doc_info.hierarchy.keys())[0]\n except:\n k = 'parameter'\n self.stype = k\n # print(self.stype)\n\n if self.stype in ['class', 'method']:\n\n # replacements.append(('{docstring}', doc_info['text']['val'][0]))\n # (not c.children and True)\n m = ''.join([c.label for c in doc_info.children if True])\n # print(m)\n replacements.append(('{docstring}', m))\n # else:\n # doc_info = object\n # WARNING\n\n content = self.template_content[self.stype]\n for r in replacements:\n content = content.replace(*r)\n\n # print(self.stype)\n if self.stype == 'method':\n pass\n elif self.stype == 'parameter':\n # param_list = []\n # print(doc_info.names())\n # if 'params' in doc_info.names():\n # print(True)\n # for k, v in doc_info['params'].items():\n # k = doc_info.label:\n # if k[0] in '!':\n # k = k[1:] + ' [required]'\n # if k[0] in '~':\n # k = k[1:] + ' [optional]'\n #\n # param_content = generate_section('parameter', v, [('{parameter}', k)])\n # param_list.append(param_content)\n content = content.replace('[params]', '\\n'.join(param_list))\n\n # content = ''\n # label = doc_info[0]['label']\n label = doc_info.label\n\n if '{ex' in label:\n examples = []\n ex_options = label[label.find('{ex'): label.find('}')+1]\n # print(ex_options)\n ex_options_ = [float(f) for f in ex_options.split(':')[1][:-1].split(',')]\n ex_options_ = ex_options_ + [1., 1., 20.][-(3-len(ex_options_)):]\n print(ex_options_)\n for l in range(int(ex_options_[0])):\n bounds = ex_options_[1:3]\n # if ex_options_[1] % 1. == 0:\n if ex_options_[1].is_integer():\n ex = random.randint(*bounds)\n else:\n ex = random.uniform(*bounds)\n\n examples.append(str(ex))\n\n examples = 'Examples: {}'.format('; '.join(['`{}`'.format(e) for e in examples]))\n label = label.replace(ex_options, examples)\n doc_info[0]['label'] = label\n content = content.replace('{label}', label)\n\n type_list = []\n for t in []:\n # print(t, 't')\n try:\n # print('[{}]'.format(','.join(t['type'])))\n y = [str(v) for v in t['type']]\n z = '[{}]'.format(','.join(y))\n print(z)\n z = z.replace(\"'\", '\"')\n # type_tags = set(json.loads(z))\n type_tags = json.loads(z)\n typestring = parse_tags(type_tags)\n print(True)\n except Exception as e:\n print(e)\n typestring = ''\n for req in t['type']:\n if req in ['int', 'str', 'float', 'bool']:\n typestring += '`{}`'.format(req)\n elif req[0] == 'r':\n if ':' in req:\n limits = req[1:].split(':')\n typestring += ' between `{}` and `{}`'.format(*limits)\n # elif any(c in req for c in '<>')\n # elif '<' in req:\n elif any(s in req for s in symbols):\n typestring += ' {} {}'.format(symbols[req[1]], req[-1])\n\n type_list.append('- {}: {}'.format(typestring, t['label']))\n\n content = content.replace('[types]', '\\n'.join(type_list))\n\n # print(doc_info.children)\n for c in doc_info.children:\n content += c.generate(template=self.template_content) + '\\n'\n\n return content","def __call__(self, doc):\n return doc","def init_doc(self):\n raise NotImplementedError()","def run(self):\n name_desc = self.__class__.name_sphinx\n settings = self.state.document.settings\n env = settings.env if hasattr(settings, \"env\") else None\n docname = None if env is None else env.docname\n tag = self.options.get('tag', '').strip()\n n = self.__class__.node_class('')\n n[\"breftag\"] = tag\n n[\"brefsort\"] = self.options.get('sort', 'title').strip()\n n[\"brefsection\"] = self.options.get(\n 'section', True) in (True, \"True\", \"true\", 1, \"1\")\n n[\"brefcontents\"] = self.options.get(\n 'contents', False) in (True, \"True\", \"true\", 1, \"1\", \"\", None, \"None\")\n n['docname'] = docname\n if env is not None:\n targetid = 'index%slist-%s' % (name_desc,\n env.new_serialno('index%slist' % name_desc))\n targetnode = nodes.target('', '', ids=[targetid])\n return [targetnode, n]\n else:\n return [n]","def show_documentation(self):\n self.docs = documentation.Documentation()","def get_doc_context(self, docname, body, metatags):\n\n # TYPO3: remove 'documentation' from end of 'shorttitle'\n shorttitle = self.globalcontext.get('shorttitle', '')\n if shorttitle and shorttitle.endswith(' documentation'):\n shorttitle = shorttitle[0:-14].rstrip()\n self.globalcontext['shorttitle'] = shorttitle\n \n\n # find out relations\n # TYPO3: always have order 'previous', 'up', 'next'\n prev = up = next = None\n parents = []\n rellinks = self.globalcontext['rellinks'][:]\n related = self.relations.get(docname)\n titles = self.env.titles\n if related and related[1]:\n try:\n prev = {\n 'link': self.get_relative_uri(docname, related[1]),\n 'title': self.render_partial(titles[related[1]])['title']\n }\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n if related and related[0]:\n try:\n up = {\n 'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']\n }\n rellinks.append((related[0], up['title'], 'U', _('up')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n if related and related[2]:\n try:\n next = {\n 'link': self.get_relative_uri(docname, related[2]),\n 'title': self.render_partial(titles[related[2]])['title']\n }\n rellinks.append((related[2], next['title'], 'N', _('next')))\n except KeyError:\n next = None\n while related and related[0]:\n try:\n parents.append(\n {'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']})\n except KeyError:\n pass\n related = self.relations.get(related[0])\n if parents:\n parents.pop() # remove link to the master file; we have a generic\n # \"back to index\" link already\n parents.reverse()\n\n # title rendered as HTML\n title = self.env.longtitles.get(docname)\n title = title and self.render_partial(title)['title'] or ''\n # the name for the copied source\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\n\n # metadata for the document\n meta = self.env.metadata.get(docname)\n\n # local TOC and global TOC tree\n self_toc = self.env.get_toc_for(docname, self)\n toc = self.render_partial(self_toc)['fragment']\n\n return dict(\n parents = parents,\n prev = prev,\n next = next,\n title = title,\n meta = meta,\n body = body,\n metatags = metatags,\n rellinks = rellinks,\n sourcename = sourcename,\n toc = toc,\n # only display a TOC if there's more than one item to show\n display_toc = (self.env.toc_num_entries[docname] > 1),\n )","def _builder_inited(app: sphinx.application.Sphinx) -> None:\n _write_member_documentation_pages(\n _create_documenter(env=app.env,\n documenter_cls=sphinx.ext.autodoc.ModuleDocumenter,\n name='tensorstore'))","async def docs(self, ctx):\n embed = discord.Embed(title = \"Documentation\", description = \"[Click here to visit our documentation!](https://dhb-documentation.readthedocs.io/en/latest/index.html)\", color = discord.Color.blurple())\n await ctx.send(embed = embed)","def build_document(self):\n pass","def generate_html(repo_dir, package_dir, module):\n apidir = os.path.join(repo_dir, 'doc', 'api')\n print(f\"Generating {module} API docs in {apidir!r}\")\n if subprocess.call(['sphinx-apidoc', '-Tef', '-o', apidir,\n os.path.join(package_dir, module),\n os.path.join(package_dir, module, 'test'),\n os.path.join(package_dir, module, 'scripts')]):\n raise RuntimeError(f'API doc generation failed for {module}')","def pydocstyle(context):\n exec_cmd = \"pydocstyle .\"\n run_cmd(context, exec_cmd)","def get_documentation(self, css_path=None, base_url=None):\n if base_url is None:\n first_key = next(iter(self.conf_doc))\n conf = self.conf_doc[first_key]\n else:\n conf = self.conf_doc[\"/\" + base_url]\n\n return (\n 200,\n \"\"\"<!DOCTYPE html>\n<html xmlns=\"http://www.w3.org/1999/xhtml\">\n <head>\n <title>%s</title>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"/>\n <meta name=\"viewport\" content=\"width=device-width\" />\n <style>%s</style>\n %s\n </head>\n <body>\n <aside>%s</aside>\n <main>%s</main>\n <section id=\"operations\">%s</section>\n <footer>%s</footer>\n </body>\n</html>\"\"\"\n % (\n self.__title(conf),\n self.__css(),\n self.__css_path(css_path),\n self.__sidebar(conf),\n self.__header(conf),\n self.__operations(conf),\n self.__footer(),\n ),\n )","def process_doxygen(self):\n if not getattr(self, \"doxygen_conf\", None):\n self.generator.bld.fatal(\"No doxygen configuration file supplied.\")\n if not isinstance(self.doxygen_conf, Node.Node):\n self.generator.bld.fatal(\"'doxygen_conf' must be a Node.\")\n\n self.create_task(\n \"doxygen\",\n self.doxygen_conf,\n cwd=self.bld.path.get_bld().abspath(),\n output=Context.STDERR,\n )","def generate():\n local('cd doc && make clean && make html')","def doc_apply(doc):\n\n def wrapper(func):\n func.__doc__ = doc\n return func\n\n return wrapper","def setup_docs(self):\n for arg in self.args:\n self.log.debug(\"Processing arg %s\" % arg)\n if isinstance(arg, dexy.doc.Doc) or isinstance(arg, dexy.doc.PatternDoc):\n doc = arg\n\n elif isinstance(arg, list):\n if not isinstance(arg[0], basestring):\n raise Exception(\"First arg %s should be a string\" % arg[0])\n if not isinstance(arg[1], dict):\n raise Exception(\"Second arg %s should be a dict\" % arg[1])\n\n if not \"*\" in arg[0]:\n doc = dexy.doc.Doc(arg[0], **arg[1])\n else:\n # This is a pattern doc or real doc TODO better way to verify?\n doc = dexy.doc.PatternDoc(arg[0], **arg[1])\n\n elif isinstance(arg, basestring):\n doc = dexy.doc.PatternDoc(arg)\n\n else:\n raise Exception(\"unknown arg type %s for arg %s\" % (arg.__class__.__name__, arg))\n\n doc.wrapper = self\n doc.setup()\n\n self.docs.append(doc)","async def create_doc(self, *args, **kwargs):\n pass","def build_docs(open_docs):\n python_call(\"pip\", [\"install\", \"src/[docs]\"])\n python_call(\"pip\", [\"install\", \"-r\", \"src/requirements.txt\"])\n python_call(\n \"ipykernel\", [\"install\", \"--user\", \"--name=za_covid_map\"]\n )\n shutil.rmtree(\"docs/build\", ignore_errors=True)\n call(\n [\n \"sphinx-apidoc\",\n \"--module-first\",\n \"-o\",\n \"docs/source\",\n \"src/za_covid_map\",\n ]\n )\n call([\"sphinx-build\", \"-M\", \"html\", \"docs/source\", \"docs/build\", \"-a\"])\n if open_docs:\n docs_page = (Path.cwd() / \"docs\" / \"build\" / \"html\" / \"index.html\").as_uri()\n secho(\"Opening {}\".format(docs_page))\n webbrowser.open(docs_page)","def __doc__(self, ???):","def docs(self):\n self._doc_info = DocumentationURL()\n self._doc_info.show()","def __call__(self, doc: Doc) -> Doc:\n return doc","def __call__(self, doc: Doc) -> Doc:\n return doc","def __init__(self,\n source_path='./*.py',\n template_path='./docs/templates/*_template.md',\n output_path='./docs/documentation.md',\n ignore=['extra']\n ):\n\n template_files = glob.glob(template_path)\n # filename = t.split('/')[-1]\n self.sources = {os.path.basename(s).split('.')[0]: os.path.normpath(s) for s in glob.glob(source_path) if not any(i in s for i in ignore)}\n self.templates = {os.path.basename(t).split('_')[0]: os.path.normpath(t) for t in template_files}\n self.output_path = output_path\n\n self.template_content = {}\n for k, v in self.templates.items():\n path = v\n with open(path, 'r') as template_file:\n self.template_content[k] = template_file.read()\n\n self.text = ''\n self.classes = []\n self.headers = ['Params', 'Returns', 'Attributes']\n self.hierarchy = [\n 'class',\n 'method',\n 'parameter',\n 'pinfo',\n 'extra'\n ]\n self.tab_length = 6","def get_doc_context(self, docname, body, metatags):\n\n # find out relations\n prev = next = None\n parents = []\n rellinks = self.globalcontext['rellinks'][:]\n related = self.relations.get(docname)\n # Populate titles with the list of longtitles from the env instead of titles\n # titles = self.env.titles\n titles = self.env.longtitles\n if related and related[2]:\n try:\n next = {\n 'link': self.get_relative_uri(docname, related[2]),\n 'title': self.render_partial(titles[related[2]])['title']\n }\n rellinks.append((related[2], next['title'], 'N', _('next')))\n except KeyError:\n next = None\n if related and related[1]:\n try:\n prev = {\n 'link': self.get_relative_uri(docname, related[1]),\n 'title': self.render_partial(titles[related[1]])['title']\n }\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n while related and related[0]:\n try:\n parents.append(\n {'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']})\n except KeyError:\n pass\n related = self.relations.get(related[0])\n if parents:\n parents.pop() # remove link to the master file; we have a generic\n # \"back to index\" link already\n parents.reverse()\n\n # title rendered as HTML\n title = self.env.longtitles.get(docname)\n title = title and self.render_partial(title)['title'] or ''\n # the name for the copied source\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\n\n # metadata for the document\n meta = self.env.metadata.get(docname)\n\n # local TOC and global TOC tree\n self_toc = self.env.get_toc_for(docname, self)\n toc = self.render_partial(self_toc)['fragment']\n\n return dict(\n parents = parents,\n prev = prev,\n next = next,\n title = title,\n meta = meta,\n body = body,\n metatags = metatags,\n rellinks = rellinks,\n sourcename = sourcename,\n toc = toc,\n # only display a TOC if there's more than one item to show\n display_toc = (self.env.toc_num_entries[docname] > 1),\n )","def docs_build(directory, site_name, view=True, assume_yes=False):\n context = toolkit.load_data_context_with_error_handling(directory)\n build_docs(context, site_name=site_name, view=view, assume_yes=assume_yes)\n toolkit.send_usage_message(\n data_context=context, event=\"cli.docs.build\", success=True\n )","def generate_docs(root_dir, session):\n ...","def get_documentation(path=\"\"):\n return \"\"\"<HTML><head><title>Python Minidoc for \"\"\"+path+\"\"\"</title></head>\n <body>\n \"\"\"+get_documentation_body(path)+\"\"\"\n </body></html>\"\"\"","def build_docs(branch):\n os.chdir(os.path.join(gitdname, 'docs'))\n sphinx_dir = os.path.join(virtual_dir,'bin')\n retcode = subprocess.call(\"make clean\", shell=True)\n if retcode != 0:\n os.chdir(dname)\n msg = \"\"\"Could not clean the html docs for branch %s\"\"\" % branch\n raise Exception(msg)\n #NOTE: The python call in the below makes sure that it uses the Python\n # that is referenced after entering the virtualenv\n sphinx_call = \" \".join(['make','html',\n \"SPHINXBUILD=' python /usr/local/bin/sphinx-build'\"])\n activate = os.path.join(virtual_dir, \"bin\", \"activate\")\n activate_virtualenv = \". \" + activate\n #NOTE: You have to enter virtualenv in the same call. As soon as the\n # child process is done, the env variables from activate are lost.\n # getting the correct env from bin/activate and passing to env is\n # annoying\n retcode = subprocess.call(\" && \".join([activate_virtualenv, sphinx_call]),\n shell=True,\n env = {'MATPLOTLIBRC' : # put this in the environment to use local rc\n '/home/skipper/statsmodels/statsmodels/tools/',\n # Need this for my openblas setup on my laptop\n 'LD_LIBRARY_PATH' : os.getenv('LD_LIBRARY_PATH')})\n\n if retcode != 0:\n os.chdir(dname)\n msg = \"\"\"Could not build the html docs for branch %s\"\"\" % branch\n raise Exception(msg)\n os.chdir(dname)","def DocString():\n return","def documentation_only():\n pass","def get_doc(self) -> Documentation:\n r : Documentation = [self.get_doc_string()]\n r_src = \"\"\n if hasattr(self,\"_path\"): r_src += \"locally at '%s'\" % (str(self._path))\n if self.url is not None: r_src += \" remote url(orig) '%s'\" % (self.url)\n r_src += \" remote url(parsed) '%s'\" % (self.git_url.as_string())\n if self.branch is not None: r_src += \" branch '%s'\" % (self.branch)\n r.append(r_src)\n r_stages = []\n for (sn,s) in self.stages.items():\n r_stages.append(sn)\n pass\n r_stages.sort()\n if len(r_stages)>0:\n r.append(\"Stages: %s\"%(\" \".join(r_stages)))\n pass\n return r","def generate_docs(self, sections):\n for docs, code in sections:\n yield docs + code","def render_documentation(app_slug: str, model_slug: str):\n context = {\"app_slug\": app_slug, \"model_slug\": model_slug}\n\n app = SLUG_MAP.get(app_slug, None)\n model_choices = (\n [model for model in app.get_models() if model.get_slug() == model_slug]\n if app is not None\n else []\n )\n model = model_choices[0] if len(model_choices) == 1 else None\n\n fields = {}\n if model is not None:\n for field in model.get_open_fields():\n\n relation = None\n if field.is_relation:\n app_slug = slugify(\n get_app_name(\n field.related_model._meta.app_config # pylint: disable=W0212\n )\n )\n relation = {\n \"model\": field.related_model.__name__,\n \"doc_link\": reverse(\n \"documentation:details\", kwargs={\"app_slug\": app_slug}\n ),\n \"model_slug\": field.related_model.get_slug(),\n }\n\n fields[field.name] = {\n \"name\": field.name,\n \"optional\": field.null,\n \"default\": field.default if field.has_default() else None,\n \"help\": convert_string(field.help_text),\n \"type\": field.get_internal_type(),\n \"relation\": relation,\n }\n\n context[\"name\"] = model.__name__\n context[\"module\"] = model.__module__\n context[\"doc\"] = convert_string(model.__doc__, wrap_blocks=True)\n context[\"base\"] = str(model.__base__.__name__)\n # For the rare case where a field name is items, prefer this key val iteration\n context[\"columns\"] = [(key, val) for key, val in fields.items()]\n\n return context","def generate_api_docs(self):\n if self.API_OUTPUT_DIR:\n args = [\n # Put documentation for each module on its own page\n '-e',\n # don't create the \"modules.rst\" file (the table of contents\n # file) as this is already provided by the package's main rst\n # file.\n '-T',\n # Overwrite existing files\n '--force',\n '-o', self.API_OUTPUT_DIR,\n # the package to generate docs from\n self.PROJECT_DIR\n ]\n excludes = [\n os.path.join(self.PROJECT_DIR, p)\n if not os.path.isabs(p) else p\n for p in self.API_EXCLUDE_DIRS\n ]\n apidoc.main(args + excludes)","def build_gitbook(certification, certification_dir, output_dir):\n return certifications_to_gitbook.create_gitbook_documentation(\n certification=certification,\n certification_dir=certification_dir,\n output_path=output_dir\n )","def generate(self):\n\n # Write Doxyfile\n doxyfile_content = DOXYFILE_TEMPLATE.format(\n name=\"wurfapi\",\n output_path=self.output_path,\n source_path=\" \".join(self.source_paths),\n recursive=\"YES\" if self.recursive else \"NO\",\n extra=\"\",\n )\n\n doxyfile_path = os.path.join(self.output_path, \"Doxyfile\")\n with open(doxyfile_path, \"w\") as doxyfile:\n\n doxyfile.write(doxyfile_content)\n\n # @todo: Doxygen generates a bunch of warnings. We should\n # propagate these somehow - if you want to know what\n # has not been documented etc.\n result = self.runner.run(\n command=self.doxygen_executable + \" Doxyfile\", cwd=self.output_path\n )\n\n # Doxygen reports warnings on stderr. So if we have some output\n # there raise it.\n self._suppress_incorrect_warnings(result.stderr)\n\n if result.stderr.output and self.warnings_as_error:\n raise wurfapi.doxygen_error.DoxygenError(result.stderr.output)\n\n # The Doxygen XML is written to the 'xml' subfolder of the\n # output directory\n return os.path.join(self.output_path, \"xml\")","def generate_code_documentation(self, output_directory: Path, module_to_document: str) -> None:\n logger.info(\"Generating code documentation\")\n pass","def task_sphinx():\n return Task(\n file_dep=[CONF], actions=[(needs, [\"sphinx\"])], uptodate=[not CONF.exists()]\n )","def doc_factory(global_config, **local_conf):\n\treturn make_app(blueprints.developer_portal, settings.ProductionConfig)","def generate_patch_build(self, domain):\n # TODO change name of def\n base_path = self.paths[\"api_doc_dir\"]\n self.generate_apidoc_patches()\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\n patch_generator.filter_for_deleted_apis()\n\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\n\n output = process.communicate()[0]\n if output:\n\n with open(self.paths[\"base_dir\"] + \"/apidoc.json\", 'w') as outfile:\n apidoc_content = {\"url\": \"https://ib-backend-dev.apigateway.in\",\n \"version\": \"0.0.1\",\n \"description\": \"\",\n \"name\": \"iBHubs_backend API Documentation\",\n \"title\": \"iBHubs_backend Documenation\"}\n json.dump(apidoc_content, outfile, indent=4)\n # by default we assume user is working at no specific branch so we fix\n # url to default above url as above , then we check if any specific parametr is given\n # and replace url with required url\n if domain != '' and domain:\n with open(self.paths[\"apidoc\"]) as src_json:\n apidoc_content = json.load(src_json)\n apidoc_content['url'] = \"https://\" + domain\n with open(self.paths[\"apidoc\"], 'w') as outfile:\n json.dump(apidoc_content, outfile, indent=4)\n try:\n os.mkdir(\"docs\")\n except OSError:\n pass\n # the below command is responsible for creating docs\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\n '-o', os.path.join(self.base_dir, 'docs'),\n '-e', 'django_swagger_utils/*',\n '-e', 'static/*',\n ], stdout=subprocess.PIPE)\n print process.communicate()[0]\n ################################################\n # hosting apidoc\n ################################################\n # obtaining the path of static folder of django-swagger-utils\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \"../..\"))\n # static_folder_path = os.path.join(django_swagger_utils_path, \"static\")\n # import shutil\n # # create a folder apidoc , delete if previously exists\n # if os.path.exists(os.path.join(static_folder_path, \"apidoc\")):\n # shutil.rmtree(os.path.join(static_folder_path, \"apidoc\"))\n # apidoc_path = os.path.join(static_folder_path, \"apidoc\")\n #\n # os.mkdir(apidoc_path)\n\n # from distutils.dir_util import copy_tree\n # copydocs from docs to apidoc in swagger utils\n # try:\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\n # except Exception as err:\n # print err\n\n # browse to localhost:<port>/static/apidoc/index.html\n\n else:\n raise CommandError(\"Help: Install apidoc: [ sudo npm install -g apidoc ]\")","def func_doc():","def event_html_page_context(app, pagename, templatename, context, doctree):\n\n reURL = re.compile('^https?://\\S+/$')\n current_builder = app.builder.name\n if current_builder == 'html' or current_builder == 'readthedocs':\n if doctree and doctree.traverse(DiscourseNode):\n if not app.config.discourse_url:\n raise DiscourseError('::discourse: directive found, but discourse_url is not set in conf.py')\n if not reURL.match(app.config.discourse_url):\n raise DiscourseError('::discourse: directive found, but discourse_url is not set properly in conf.py (must be a valid URL starting with http:// or https:// and ending with trailing slash)')\n for discourse_node in doctree.traverse(DiscourseNode):\n context['body'] += \"\"\"<script type='text/javascript'>\n DiscourseEmbed = { discourseUrl: '%s',\n topicId: '%s' };\n (function() {\n var d = document.createElement('script'); d.type = 'text/javascript'; d.async = true;\n d.src = DiscourseEmbed.discourseUrl + 'javascripts/embed.js';\n (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(d);\n })();\n </script>\"\"\" % (app.config.discourse_url, discourse_node.get_topic_identifier())","def get_test_doc(self, name, doc_string=None):\n # PARSE OUT THE DOXYGEN SETTINGS FROM THE STRING\n doc_string = doc_string if doc_string is not None else self._testMethodDoc\n doc_list = [x.strip().replace('\\t', '') for x in doc_string.split('\\n') if len(x.strip().replace('\\t', '')) > 0]\n # CREATE DOC DICT OBJECT\n doc_dict = dict(name=name, title=doc_list[0], bug='', tags=[])\n for val in doc_list[1:]:\n if '@test' in val:\n doc_dict['test'] = val[5:]\n elif '@arg' in val:\n doc_dict['tags'] = [x.lower() for x in val[4:].split()]\n elif '@attention' in val:\n doc_dict['priority'] = val[10:]\n elif '@author' in val:\n doc_dict['author'] = val[7:]\n elif '@date' in val:\n doc_dict['date'] = val[5:]\n elif '@bug' in val:\n doc_dict['bug'] = val[4:].strip()\n elif '@version' in val:\n doc_dict['version'] = int(val[8:].replace(\".\", \"\"))\n elif '@deprecated' in val:\n doc_dict['deprecated'] = True\n elif '@note' in val:\n env_result = re.findall('ENV=(\\w+)', val.upper())\n if len(env_result) > 0:\n doc_dict['datacenters'] = env_result\n env_not = re.findall('ENV!=(\\w+)', val.upper())\n if len(env_not) > 0:\n doc_dict['no_environment'] = env_not\n priority = re.findall('priority=(\\d)', val.lower())\n if len(priority) > 0:\n doc_dict['priority'] = priority[0]\n else:\n doc_dict['note'] = val[5:]\n # CHECK IF TITLE AND NOTE NOT IN DOC_DICT\n if 'title' not in doc_dict:\n doc_dict['Title'] = 'TEST DOCUMENTATION DOES NOT INCLUDE THE TEST TITLE'\n if 'test' not in doc_dict:\n doc_dict['Test'] = 'TEST DOCUMENTATION DOES NOT INCLUDE TEST DESCRIPTION'\n self.doc_dict = doc_dict","def docstrings(param1, param2):\n return \"example string\"","def sphinx(name, options='', dirname='sphinx-rootdir',\n theme='pyramid', automake_sphinx_options='',\n split=False):\n if name.endswith('.do.txt'):\n name = name.replace('.do.txt', '')\n\n if name.endswith('.do'):\n name = name.replace('.do','')\n\n # Compile source\n cmd = 'doconce format sphinx %(name)s %(options)s ' % vars()\n system(cmd)\n\n if split:\n cmd = 'doconce split_rst %(name)s' % vars()\n\n # Create sphinx directory\n cmd = 'doconce sphinx_dir theme=%(theme)s %(name)s' % vars()\n system(cmd)\n\n # Compile sphinx\n cmd = 'python automake_sphinx.py %(automake_sphinx_options)s' % vars()\n system(cmd)","def build(working_directory, configuration):\n\n # Copy README.rst to docs/temp/README.html\n # Doxygen may not create the output folder, ensure it exists.\n\n temp_dir = os.path.join(working_directory, \"temp\")\n create_folder_if_needed(temp_dir)\n\n # Needed for dot generated docs\n create_folder_if_needed(os.path.join(temp_dir, \"images\"))\n\n # Process all the .dot files\n for item in os.listdir(working_directory):\n\n # Process the .dot files\n if _DOT_MATCH.match(item):\n # Call dot to create the files\n run_command(\n (\"dot\", \"-Tpng\", item, \"-otemp{0}images{0}{1}.png\".format(\n os.sep, item[:-4])),\n working_dir=working_directory)\n\n\n # Get the input and output file names\n source = os.path.join(os.path.dirname(working_directory), \"README.rst\")\n dest = os.path.join(temp_dir, \"README.html\")\n\n # Was the file already created and newer than the source?\n if is_source_newer(source, dest):\n\n # Load pandoc if needed to do the conversion\n pypandoc.ensure_pandoc_installed(delete_installer=True)\n pypandoc.convert_file(source, to=\"html\", outputfile=dest)\n return 0","def main():\n sys.argv.extend(('--linklint-dir', THIS_DIR,\n '--source-dir', os.path.join(THIS_DIR, 'src'),\n '--project-dir', PROJECT_DIR))\n return docs.generate_docs.main()","def gen_example_rst(example):\n if not example:\n return \"\"\n res = \"\"\"**Example**\n\n.. literalinclude:: /samples/{example}/CMakeLists.txt\n :language: cmake\n\n\"\"\"\n return res.format(example=example)","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def StartDoc(*args, **kwargs):\n return _gdi_.GraphicsContext_StartDoc(*args, **kwargs)","def makeDocFile(self):\n\n f_out = \"%s/%s-doc.php\" % (self.dir_out, self.project_id)\n version = max(self.versions)\n\n with open(f_out, 'w') as f:\n f.write(\"<!DOCTYPE html>\\n\" \\\n \"<html xmlns=\\\"http://www.w3.org/1999/xhtml\\\">\\n\" \\\n \"<head>\\n\" \\\n \"<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n\" \\\n \"\\n\" \\\n \"<title>Kit&Pack − Ultimate Power Booster</title>\\n\" \\\n \"<link rel=\\\"shortcut icon\\\" type=\\\"image/png\\\" href=\\\"../favicon.png\\\"/>\" \\\n \"<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"../css/doc-2.css\\\" />\\n\"\n \"\\n\" \\\n \"</head>\\n\" \\\n \"<body>\\n\" \\\n \"\\n\" \\\n \"<h1>Ultimate Power Booster</h1>\" \\\n \"\\n\")\n\n # Write a list of other versions of the documentation\n f.write(\"<p>Versions de cette documentation.</p>\\n\")\n f.write(\"<ul>\\n\")\n for v in self.versions:\n f.write(\"\\t<li><a href=\\\"%s.php\\\">%s</a></li>\\n\" % (\n v, v))\n f.write(\"</ul>\\n\\n\")\n\n f.write(\"<?php\\n\" \\\n \"include(\\\"%s.php\\\")\\n\" \\\n \"?>\\n\" \\\n \"\\n\" \\\n \"</body>\\n\" \\\n \"</html>\" % (version))","def test_buildWithPolicy(self):\n stdout = StringIO()\n self.patch(sys, 'stdout', stdout)\n docstring = \"text in docstring\"\n\n projectRoot = FilePath(self.mktemp())\n packagePath = projectRoot.child(\"twisted\")\n packagePath.makedirs()\n packagePath.child(\"__init__.py\").setContent(\n \"def foo():\\n\"\n \" '%s'\\n\" % (docstring,))\n packagePath.child(\"_version.py\").setContent(\n genVersion(\"twisted\", 1, 0, 0))\n outputPath = FilePath(self.mktemp())\n\n script = BuildAPIDocsScript()\n script.buildAPIDocs(projectRoot, outputPath)\n\n indexPath = outputPath.child(\"index.html\")\n self.assertTrue(\n indexPath.exists(),\n \"API index %r did not exist.\" % (outputPath.path,))\n self.assertIn(\n '<a href=\"http://twistedmatrix.com/\">Twisted</a>',\n indexPath.getContent(),\n \"Project name/location not in file contents.\")\n\n twistedPath = outputPath.child(\"twisted.html\")\n self.assertTrue(\n twistedPath.exists(),\n \"Package documentation file %r did not exist.\"\n % (twistedPath.path,))\n self.assertIn(\n docstring, twistedPath.getContent(),\n \"Docstring not in package documentation file.\")\n #Here we check that it figured out the correct version based on the\n #source code.\n self.assertIn(\n '<a href=\"http://twistedmatrix.com/trac/browser/tags/releases/'\n 'twisted-1.0.0/twisted\">View Source</a>',\n twistedPath.getContent())\n\n self.assertEqual(stdout.getvalue(), '')","def makedocs(projectfolder):\n featuremodel_path = path.join(projectfolder, \"productline\", \"model.xml\")\n configs_path = path.join(projectfolder, \"productline\", \"configs\")\n bddfeatures_path = path.join(projectfolder, \"bddfeatures\")\n testreports_path = path.join(projectfolder, \"testreports\")\n\n fmparser = parsers.FeatureModelParser()\n resultsparser = parsers.TestResultsParser()\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\n\n docs_dir = path.join(projectfolder, \"docs/generated\")\n if path.exists(docs_dir):\n shutil.rmtree(docs_dir)\n makedirs(docs_dir)\n\n lektor_templates_path = \"doc_templates\"\n utilities.sed_inplace(\n path.join(lektor_templates_path, \"aplet.lektorproject\"),\n r'<<PROJECT>>',\n CONFIG[\"project_name\"])\n\n products = {}\n product_names = get_product_names_from_configs_path(configs_path)\n for product_name in product_names:\n productconfig_filepath = path.join(projectfolder, \"productline/configs\", product_name + \".config\")\n product_html_report_name = \"report{0}.html\".format(product_name)\n product_html_results_src = path.join(testreports_path, product_html_report_name)\n product_xml_report_name = \"report{0}.xml\".format(product_name)\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\n\n with open(productconfig_filepath, \"r\") as productconfig_file:\n products[product_name] = {}\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\n\n current_product_lektor_dir = path.join(lektor_templates_path, \"content/products\", product_name)\n if not path.exists(current_product_lektor_dir):\n makedirs(current_product_lektor_dir)\n\n product_filepath = path.join(current_product_lektor_dir,\"contents.lr\")\n shutil.copyfile(path.join(lektor_templates_path, \"helpers/product_contents.lr\"), product_filepath)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\n product_features = configparser.parse_config(productconfig_filepath)\n feature_model.trim_based_on_config(product_features)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \"feature_model\")\n\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\n product_test_status = feature_model.root_feature.test_status\n utilities.sed_inplace(product_filepath, \"<<TEST_STATUS>>\", product_test_status.name)\n\n # Copy test run html report to generated docs\n if path.exists(product_html_results_src):\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\n\n click.echo(\"- Generating feature model SVG...\")\n click.echo(featuremodel_path)\n\n feature_model = fmparser.parse_from_file(featuremodel_path)\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\n feature_model.add_gherkin_pieces(gherkin_pieces)\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\n\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \"content/\"), \"feature_model\")\n\n click.echo(\"- Building site\")\n lektor_cmd = [\"lektor\", \"--project\", lektor_templates_path, \"build\", \"-O\", path.abspath(docs_dir)]\n click.echo(\"Running: \" + subprocess.list2cmdline(lektor_cmd))\n subprocess.call(lektor_cmd)\n\n product_map_renderer = mapbuilder.ProductMapRenderer()\n productline_generated_filepath = path.join(docs_dir, \"index.html\")\n html = product_map_renderer.get_productmap_html(feature_model, products)\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)","def test_build(self):\n stdout = StringIO()\n self.patch(sys, 'stdout', stdout)\n\n projectName = \"Foobar\"\n packageName = \"quux\"\n projectURL = \"scheme:project\"\n sourceURL = \"scheme:source\"\n docstring = \"text in docstring\"\n privateDocstring = \"should also appear in output\"\n\n inputPath = FilePath(self.mktemp()).child(packageName)\n inputPath.makedirs()\n inputPath.child(\"__init__.py\").setContent(\n \"def foo():\\n\"\n \" '%s'\\n\"\n \"def _bar():\\n\"\n \" '%s'\" % (docstring, privateDocstring))\n\n outputPath = FilePath(self.mktemp())\n outputPath.makedirs()\n\n builder = APIBuilder()\n builder.build(projectName, projectURL, sourceURL, inputPath, outputPath)\n\n indexPath = outputPath.child(\"index.html\")\n self.assertTrue(\n indexPath.exists(),\n \"API index %r did not exist.\" % (outputPath.path,))\n self.assertIn(\n '<a href=\"%s\">%s</a>' % (projectURL, projectName),\n indexPath.getContent(),\n \"Project name/location not in file contents.\")\n\n quuxPath = outputPath.child(\"quux.html\")\n self.assertTrue(\n quuxPath.exists(),\n \"Package documentation file %r did not exist.\" % (quuxPath.path,))\n self.assertIn(\n docstring, quuxPath.getContent(),\n \"Docstring not in package documentation file.\")\n self.assertIn(\n '<a href=\"%s/%s\">View Source</a>' % (sourceURL, packageName),\n quuxPath.getContent())\n self.assertIn(\n '<a href=\"%s/%s/__init__.py#L1\" class=\"functionSourceLink\">' % (\n sourceURL, packageName),\n quuxPath.getContent())\n self.assertIn(privateDocstring, quuxPath.getContent())\n\n # There should also be a page for the foo function in quux.\n self.assertTrue(quuxPath.sibling('quux.foo.html').exists())\n\n self.assertEqual(stdout.getvalue(), '')","def build(_):","async def handle_doc(self, request: web.Request) -> web.Response:\n spec = request.app[\"spec\"]\n spec_url = request.app.router[\"openapi_spec\"].url_for()\n title = spec.info.title\n html = f\"\"\"\n <!DOCTYPE html>\n <html>\n <head>\n <title>{title}</title>\n <!-- needed for adaptive design -->\n <meta charset=\"utf-8\"/>\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n \"\"\"\n if self.font:\n html += f\"\"\"\n <link href=\"https://fonts.googleapis.com/css?{self.font}\" rel=\"stylesheet\">\n \"\"\"\n html += f\"\"\"\n <link rel=\"shortcut icon\" href=\"{self.favicon_url}\">\n <!--\n ReDoc doesn't change outer page styles\n -->\n <style>\n body {{\n margin: 0;\n padding: 0;\n }}\n </style>\n </head>\n <body>\n <redoc spec-url=\"{spec_url}\"></redoc>\n <script src=\"{self.redoc_js_url}\"> </script>\n </body>\n </html>\n \"\"\"\n return web.Response(text=html, content_type=\"text/html\")","def get_documentation():\n return send_file(base_dir / \"static/documentation.html\", \"text/html; charset=UTF-8\")","def getDoc(self):\r\n return self.__doc__","def do_docs(self, path):\n print(\"scaraping documentation\")\n for p in path.glob(\"**/*\"):\n if p.is_file():\n parts = p.relative_to(path).parts\n if parts[-1].endswith(\"rst\"):\n data = tsparse(p.read_bytes())\n blob = DocBlob()\n blob.arbitrary = data\n blob.content = {}\n\n blob.ordered_sections = []\n blob.item_file = None\n blob.item_line = None\n blob.item_type = None\n blob.aliases = []\n blob.example_section_data = Section()\n blob.see_also = []\n blob.signature = None\n blob.references = None\n blob.refs = []\n\n self.docs[parts] = json.dumps(blob.to_json(), indent=2)\n else:\n pass\n # data = p.read_bytes()","def main():\n\n return redirect('/apidocs')","def _rapidoc(request: HttpRequest) -> HttpResponse:\n return render(request, 'rapidoc.html', {\n 'schema': reverse('api:v2:schema'),\n })","def _add_doc(func, doc):\n func.__doc__ = doc","def build_pages(ctx, show=False):\n\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\n import pages\n import webbrowser\n\n # Update all readmes first\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\n for line in lines:\n print(subprocess.getoutput(['invoke', line]))\n\n pages.build(True, False)\n if show:\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))","def html():\n builtdocs = path(\"docs\") / options.sphinx.builddir / \"html\"\n destdir = path(PACKAGE) / \"docs\"\n destdir.rmtree()\n builtdocs.move(destdir)","def __buildDocumentClassDocString():\n\n # build a dictionary of tags and their descriptions, seems a little over\n # the top, but keeps all the information in one place\n tagsStrings = {\n \"comment\" : \"Define the comment string\",\n \"define\" : \"Define the symbol name for #define's\",\n \"info\" : \"Information string, to end up in the 'info' output\",\n \"instance\" : \"Instance name\",\n \"matlabRoot\" : \"Name of variable used by the matlab output\",\n \"members\" : \"List of symbols, which are going to be children of this symbol\",\n \"name\" : \"Name of this symbol\",\n \"size\" : \"Size of this symbol, i.e. indicate it is an array\",\n \"subtype\" : \"Define the actual type of general symbol\",\n \"symbol\" : \"Define a symbol, either a top level entity a child in a members\",\n \"test\" : \"Define the preprocessor test\",\n \"text\" : \"Text to put into a banner symbol\",\n \"title\" : \"Set the overall document title\",\n \"value\" : \"Define a value for this symbol\",\n \"valuesRequired\" : \"Does the enumeration allow automatic value assignment in entries\",\n }\n # build the list of classes\n classes = dict(filter(lambda (k,v): type(v) == types.ClassType, globals().iteritems()))\n (tagsUsed, optionsUsed) = buildKeys(classes)\n\n # build the string we are going to add to the document class\n s = \"Document class that represents the XML document and contains the data.\\n\\n\"\n s += \"Available tags:\\n\"\n\n for tag in tagsStrings:\n try:\n used = \" Required by : %s\\n\" % (\", \".join(tagsUsed[tag]))\n except KeyError:\n used = \"\"\n try:\n opts = \" Optional for: %s\\n\" % (\", \".join(optionsUsed[tag]))\n except KeyError:\n opts = \"\"\n s += \" %s\\n %s\\n %s\\n\\n%s%s\\n\" % (tag, \"-\"*len(tag), tagsStrings[tag], used, opts)\n\n return s","def Init(self, *args):\n return _XCAFDoc.XCAFDoc_DocumentTool_Init(self, *args)","def store_documentation(self, file_path, *args, **dargs):\n pass","def _call_build(*, build, out_dir):\n with tempfile.TemporaryDirectory(\n dir=os.environ.get(\"TEST_TMPDIR\"),\n prefix=\"doc_builder_temp_\") as temp_dir:\n return build(out_dir=out_dir, temp_dir=temp_dir)","def _get_doc(self, name):\r\n doc = \"No documentation for %s\" % name\r\n\r\n engine = self._engine\r\n if not engine:\r\n msg = \"Session is not open\"\r\n raise Oct2PyError(msg)\r\n doc = engine.eval('help(\"%s\")' % name, silent=True)\r\n\r\n if \"syntax error:\" in doc.lower():\r\n raise Oct2PyError(doc)\r\n\r\n if \"error:\" in doc.lower():\r\n doc = engine.eval('type(\"%s\")' % name, silent=True)\r\n doc = \"\\n\".join(doc.splitlines()[:3])\r\n\r\n default = self.feval.__doc__\r\n default = \" \" + default[default.find(\"func_args:\") :] # type:ignore\r\n default = \"\\n\".join([line[8:] for line in default.splitlines()])\r\n\r\n doc = \"\\n\".join(doc.splitlines())\r\n doc = \"\\n\" + doc + \"\\n\\nParameters\\n----------\\n\" + default\r\n doc += \"\\n**kwargs - Deprecated keyword arguments\\n\\n\"\r\n doc += \"Notes\\n-----\\n\"\r\n doc += \"Keyword arguments to dynamic functions are deprecated.\\n\"\r\n doc += \"The `plot_*` kwargs will be ignored, but the rest will\\n\"\r\n doc += \"used as key - value pairs as in version 3.x.\\n\"\r\n doc += \"Use `set_plot_settings()` for plot settings, and use\\n\"\r\n doc += \"`func_args` directly for key - value pairs.\"\r\n return doc"],"string":"[\n \"def sphinxify(docstring, context, buildername='html'):\\n\\n srcdir = mkdtemp()\\n srcdir = encoding.to_unicode_from_fs(srcdir)\\n\\n base_name = osp.join(srcdir, 'docstring')\\n rst_name = base_name + '.rst'\\n\\n if buildername == 'html':\\n suffix = '.html'\\n else:\\n suffix = '.txt'\\n output_name = base_name + suffix\\n\\n # This is needed so users can type \\\\\\\\ on latex eqnarray envs inside raw\\n # docstrings\\n if context['right_sphinx_version'] and context['math_on']:\\n docstring = docstring.replace('\\\\\\\\\\\\\\\\', '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\')\\n \\n # Add a class to several characters on the argspec. This way we can\\n # highlight them using css, in a similar way to what IPython does.\\n argspec = context['argspec']\\n for char in ['=', ',', '(', ')', '*', '**']:\\n argspec = argspec.replace(char,\\n '<span class=\\\"argspec-highlight\\\">' + char + '</span>')\\n context['argspec'] = argspec\\n\\n doc_file = codecs.open(rst_name, 'w', encoding='utf-8')\\n doc_file.write(docstring)\\n doc_file.close()\\n \\n temp_confdir = False\\n if temp_confdir:\\n # TODO: This may be inefficient. Find a faster way to do it.\\n confdir = mkdtemp()\\n confdir = encoding.to_unicode_from_fs(confdir)\\n generate_configuration(confdir)\\n else:\\n confdir = osp.join(get_module_source_path('spyderlib.utils.inspector'))\\n\\n confoverrides = {'html_context': context}\\n\\n doctreedir = osp.join(srcdir, 'doctrees')\\n\\n sphinx_app = Sphinx(srcdir, confdir, srcdir, doctreedir, buildername,\\n confoverrides, status=None, warning=None,\\n freshenv=True, warningiserror=False, tags=None)\\n try:\\n sphinx_app.build(None, [rst_name])\\n except SystemMessage:\\n output = _(\\\"It was not possible to generate rich text help for this \\\"\\n \\\"object.</br>\\\"\\n \\\"Please see it in plain text.\\\")\\n return warning(output)\\n\\n # TODO: Investigate if this is necessary/important for us\\n if osp.exists(output_name):\\n output = codecs.open(output_name, 'r', encoding='utf-8').read()\\n output = output.replace('<pre>', '<pre class=\\\"literal-block\\\">')\\n else:\\n output = _(\\\"It was not possible to generate rich text help for this \\\"\\n \\\"object.</br>\\\"\\n \\\"Please see it in plain text.\\\")\\n return warning(output)\\n\\n if temp_confdir:\\n shutil.rmtree(confdir, ignore_errors=True)\\n shutil.rmtree(srcdir, ignore_errors=True)\\n\\n return output\",\n \"def generate_documentation(self):\\n self.generate_api_docs()\\n build.main([\\n self.SOURCE_DIR,\\n self.BUILD_DIR,\\n ])\",\n \"def buildDocumentation():\\n helptext = 'usage: build_doc.py <output format> <type of documentation>' \\\\\\n '\\\\n - html: for html output' \\\\\\n '\\\\n - pdf: for pdf output' \\\\\\n '\\\\n\\\\n - all: complete documentation' \\\\\\n '\\\\n - dev: only developer documentation' \\\\\\n '\\\\n - user: only user documentation'\\n if len(sys.argv) != 3:\\n print helptext\\n sys.exit(1)\\n\\n if sys.argv[1] not in ['pdf', 'html']:\\n print helptext\\n sys.exit(1)\\n if sys.argv[2] not in ['all', 'dev', 'user']:\\n print helptext\\n sys.exit(1)\\n\\n copyfile('docs/index_%s.rst.template' % sys.argv[2], 'index.rst') # copy main file into root directory\\n os.system('sphinx-build -b %s -c docs -D master_doc=index . docs/output/%s/%s' % (sys.argv[1], sys.argv[1], sys.argv[2]))\\n os.remove('index.rst') # delete config file from root directory\",\n \"def sphinxify(docstring, context, buildername='html', img_path=''):\\n if img_path:\\n if os.name == 'nt':\\n img_path = img_path.replace('\\\\\\\\', '/')\\n leading = '/' if os.name.startswith('posix') else ''\\n docstring = docstring.replace('_images', leading+img_path)\\n\\n srcdir = osp.join(DOCDIR, '_sources')\\n if not osp.exists(srcdir):\\n os.makedirs(srcdir)\\n base_name = osp.join(srcdir, xrtQookPageName)\\n rst_name = base_name + '.rst'\\n\\n # This is needed so users can type \\\\\\\\ on latex eqnarray envs inside raw\\n # docstrings\\n docstring = docstring.replace('\\\\\\\\\\\\\\\\', '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\')\\n\\n # Add a class to several characters on the argspec. This way we can\\n # highlight them using css, in a similar way to what IPython does.\\n # NOTE: Before doing this, we escape common html chars so that they\\n # don't interfere with the rest of html present in the page\\n argspec = escape(context['argspec'])\\n for char in ['=', ',', '(', ')', '*', '**']:\\n argspec = argspec.replace(\\n char, '<span class=\\\"argspec-highlight\\\">' + char + '</span>')\\n context['argspec'] = argspec\\n\\n doc_file = codecs.open(rst_name, 'w', encoding='utf-8')\\n doc_file.write(docstring)\\n doc_file.close()\\n\\n confoverrides = {'html_context': context,\\n 'extensions': ['sphinx.ext.mathjax',\\n 'sphinxcontrib.jquery']}\\n\\n doctreedir = osp.join(DOCDIR, 'doctrees')\\n sphinx_app = Sphinx(srcdir, DOCDIR, DOCDIR, doctreedir, buildername,\\n confoverrides, status=None, warning=None,\\n freshenv=True, warningiserror=False, tags=None)\\n\\n try:\\n sphinx_app.build(None, [rst_name])\\n except SystemMessage:\\n pass\",\n \"def documentation():\\n return render_template('help.html')\",\n \"def build(\\n ctx,\\n skip,\\n enable_doxygen_conf,\\n enable_doxygen,\\n enable_symlinks,\\n enable_sphinx,\\n use_doxygen_conf_in,\\n doxygen_conf_defaults_path,\\n dox,\\n skip_dox,\\n warning_is_error,\\n nitpicky,\\n):\\n root_project_dir = discover_conf_py_directory(ctx.obj[\\\"root_project_dir\\\"])\\n\\n if doxygen_conf_defaults_path is not None:\\n _doxygen_conf_defaults_path = Path(doxygen_conf_defaults_path)\\n else:\\n _doxygen_conf_defaults_path = None\\n\\n return_code = build_stack_docs(\\n root_project_dir,\\n skipped_names=skip,\\n prefer_doxygen_conf_in=use_doxygen_conf_in,\\n doxygen_conf_defaults_path=_doxygen_conf_defaults_path,\\n enable_doxygen_conf=enable_doxygen_conf,\\n enable_doxygen=enable_doxygen,\\n enable_package_links=enable_symlinks,\\n enable_sphinx=enable_sphinx,\\n select_doxygen_packages=dox,\\n skip_doxygen_packages=skip_dox,\\n warning_is_error=warning_is_error,\\n nitpicky=nitpicky,\\n )\\n if return_code > 0:\\n sys.exit(return_code)\",\n \"def doc(self):\\n from distutils.dir_util import copy_tree\\n\\n def copy_tree_checker(src, dst):\\n \\\"\\\"\\\"Wrap copy_tree to avoid pydoit error.\\\"\\\"\\\"\\n copy_tree(src, dst)\\n return True\\n\\n return {\\n \\\"actions\\\": [\\n (create_dir, [\\\"build/doc/source\\\"]),\\n (copy_tree_checker, [\\\"docs\\\", \\\"build/doc/source\\\"]),\\n TaskCreator.get_sphinx() + \\\"-apidoc -o build/doc/source --force --separate --module-first \\\" + self.project_name_sc,\\n TaskCreator.get_sphinx() + \\\"-build -j auto -n build/doc/source build/doc/html\\\"\\n ],\\n \\\"verbosity\\\": 2\\n }\",\n \"def beehive_make_doc(self):\\n run_data = {\\n u'tags':[u'doc'],\\n u'local_package_path':self.local_package_path\\n } \\n self.ansible_playbook(u'docs', run_data, \\n playbook=self.beehive_doc_playbook)\",\n \"def docs():\\n sh('sphinx-build -W -b html docs docs/_build/html')\",\n \"def get_documentation(self, *args, **dargs):\\n pass\",\n \"def build_docs(source, destination, doctrees):\\n sphinx_argv = [\\n '-b', 'html',\\n '-d', doctrees,\\n source,\\n destination]\\n\\n sphinx_main(['sphinx-build'] + sphinx_argv)\",\n \"def generate_context(name='', argspec='', note='', math=False, collapse=False,\\n img_path=''):\\n \\n context = \\\\\\n {\\n # Arg dependent variables\\n 'math_on': 'true' if math else '',\\n 'name': name,\\n 'argspec': argspec,\\n 'note': note,\\n 'collapse': collapse,\\n 'img_path': img_path,\\n \\n # Static variables\\n 'css_path': CSS_PATH,\\n 'js_path': JS_PATH,\\n 'jquery_path': JQUERY_PATH,\\n 'mathjax_path': MATHJAX_PATH,\\n 'right_sphinx_version': '' if sphinx.__version__ < \\\"1.1\\\" else 'true',\\n 'platform': sys.platform\\n }\\n \\n return context\",\n \"def main():\\n # We know that qidoc build will set the correct cwd\\n qibuild_dir = \\\"..\\\"\\n qibuild_dir = os.path.abspath(qibuild_dir)\\n this_file = __file__\\n this_dir = os.path.dirname(this_file)\\n cmake_api = os.path.join(this_dir, \\\"../source/advanced/cmake/api\\\")\\n cmake_api = os.path.abspath(cmake_api)\\n if not os.path.exists(cmake_api):\\n os.makedirs(cmake_api)\\n qibuild_cmake = os.path.join(qibuild_dir, \\\"cmake\\\", \\\"qibuild\\\")\\n for filename in DOCUMENTED_FILES:\\n cmake_file = os.path.join(qibuild_cmake, filename + \\\".cmake\\\")\\n rst_file = os.path.join(cmake_api, filename + \\\".rst\\\")\\n gen_cmake_doc(cmake_file, rst_file)\",\n \"def docs():\",\n \"def with_docs(self):\\r\\n self._configurations.append('javadoc')\\r\\n return self\",\n \"def build_docs(session):\\n envbindir = session.bin\\n session.install(\\\"-e\\\", \\\".[all,docs]\\\")\\n with session.chdir(\\\"docs/\\\"):\\n session.run(\\n \\\"sphinx-autobuild\\\",\\n \\\"-j\\\",\\n \\\"auto\\\",\\n \\\"--open-browser\\\",\\n \\\"-qT\\\",\\n \\\".\\\",\\n f\\\"{envbindir}/../tmp/html\\\",\\n )\",\n \"def test_doc():\\n pass\",\n \"def docs(command, warn_is_error=False, options=\\\"\\\"):\\n print(\\n \\\"\\\"\\\"\\nRunning Sphinx to test the docs building\\n========================================\\n\\\"\\\"\\\"\\n )\\n o = \\\"-W \\\" if warn_is_error else \\\"\\\"\\n if \\\"-W\\\" in options:\\n options = options.replace(\\\"-W\\\", \\\"\\\")\\n options = options + \\\" \\\" + o\\n shutil.rmtree(\\\"docs/_build\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/api\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/code_reference/api\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/jupyter_execute\\\", ignore_errors=True)\\n shutil.rmtree(\\\"docs/examples/default_config.yaml\\\", ignore_errors=True)\\n command.run(\\\"python -m boa.config --output-path docs/examples/default_config.yaml\\\", echo=True, pty=POSIX)\\n command.run(f\\\"sphinx-build {options} -b html docs docs/_build\\\", echo=True, pty=POSIX)\",\n \"def main_docstring():\",\n \"def build_docs(options):\\r\\n verbose = getattr(options, 'verbose', False)\\r\\n\\r\\n cmd = \\\"cd {dir}; make html quiet={quiet}\\\".format(\\r\\n dir=doc_path(options),\\r\\n quiet=\\\"false\\\" if verbose else \\\"true\\\"\\r\\n )\\r\\n\\r\\n sh(cmd)\",\n \"def documentation():\\n return auto.html()\",\n \"def main(*, build, subdir, description, supports_modules=False,\\n supports_quick=False):\\n parser = argparse.ArgumentParser(description=description)\\n group = parser.add_mutually_exclusive_group()\\n group.add_argument(\\n \\\"--serve\\\", action='store_true',\\n help=\\\"Serve the documentation on the given PORT for easy preview.\\\")\\n group.add_argument(\\n \\\"--out_dir\\\", type=str, metavar=\\\"DIR\\\",\\n help=\\\"Generate the documentation to the given output directory.\\\"\\n \\\" The DIR must be an absolute path.\\\"\\n \\\" If DIR already exists, then it must be empty.\\\"\\n \\\" (For regression testing, the DIR can be the magic value <test>,\\\"\\n \\\" in which case a $TEST_TMPDIR subdir will be used.)\\\")\\n parser.add_argument(\\n \\\"--port\\\", type=int, metavar=\\\"PORT\\\", default=8000,\\n help=\\\"Use a non-default PORT when serving for preview.\\\")\\n parser.add_argument(\\n \\\"--verbose\\\", action=\\\"store_true\\\",\\n help=\\\"Echo detailed commands, progress, etc. to the console\\\")\\n if supports_modules:\\n parser.add_argument(\\n \\\"module\\\", nargs=\\\"*\\\",\\n help=\\\"Limit the generated documentation to only these modules and \\\"\\n \\\"their children. When none are provided, all will be generated. \\\"\\n \\\"For example, specify drake.math or drake/math for the C++ \\\"\\n \\\"module, or pydrake.math or pydrake/math for the Python module.\\\")\\n if supports_quick:\\n parser.add_argument(\\n \\\"--quick\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Omit from the output items that are slow to generate. \\\"\\n \\\"This yields a faster preview, but the output will be incomplete.\\\")\\n args = parser.parse_args()\\n if args.verbose:\\n global _verbose\\n _verbose = True\\n curried_build = build\\n if supports_modules:\\n canonicalized_modules = [\\n x.replace('/', '.')\\n for x in args.module\\n ]\\n curried_build = functools.partial(\\n curried_build, modules=canonicalized_modules)\\n if supports_quick:\\n curried_build = functools.partial(\\n curried_build, quick=args.quick)\\n if args.out_dir is None:\\n assert args.serve\\n _do_preview(build=curried_build, subdir=subdir, port=args.port)\\n else:\\n _do_generate(build=curried_build, out_dir=args.out_dir,\\n on_error=parser.error)\",\n \"def test_html_documentation(self):\\n app = Sphinx(\\n self.source_dir,\\n self.config_dir,\\n self.output_dir,\\n self.doctree_dir,\\n buildername='html',\\n warningiserror=True,\\n )\\n app.build(force_all=self.all_files)\",\n \"def _sphinx_build(self, kind: str):\\n if kind not in (\\\"html\\\", \\\"latex\\\"):\\n raise ValueError(f\\\"kind must be html or latex, not {kind}\\\")\\n\\n cmd = [\\\"sphinx-build\\\", \\\"-b\\\", kind]\\n if self.num_jobs:\\n cmd += [\\\"-j\\\", self.num_jobs]\\n if self.warnings_are_errors:\\n cmd += [\\\"-W\\\", \\\"--keep-going\\\"]\\n if self.verbosity:\\n cmd.append(f\\\"-{'v' * self.verbosity}\\\")\\n cmd += [\\n \\\"-d\\\",\\n os.path.join(BUILD_PATH, \\\"doctrees\\\"),\\n SOURCE_PATH,\\n os.path.join(BUILD_PATH, kind),\\n ]\\n return subprocess.call(cmd)\",\n \"def _sphinx_build(self, kind: str):\\n if kind not in (\\\"html\\\", \\\"latex\\\"):\\n raise ValueError(f\\\"kind must be html or latex, not {kind}\\\")\\n\\n cmd = [\\\"sphinx-build\\\", \\\"-b\\\", kind]\\n if self.num_jobs:\\n cmd += [\\\"-j\\\", self.num_jobs]\\n if self.warnings_are_errors:\\n cmd += [\\\"-W\\\", \\\"--keep-going\\\"]\\n if self.verbosity:\\n cmd.append(f\\\"-{'v' * self.verbosity}\\\")\\n cmd += [\\n \\\"-d\\\",\\n os.path.join(BUILD_PATH, \\\"doctrees\\\"),\\n SOURCE_PATH,\\n os.path.join(BUILD_PATH, kind),\\n ]\\n return subprocess.call(cmd)\",\n \"def apiDocs():\\n\\treturn render_template('apiDocs.html')\",\n \"def run():\\n build_no_documentation()\\n build_sphinx_build()\\n #build_sphinx_pdf()\\n build_graphviz_files()\",\n \"def to_markdown_with_context(context: Context, docstring: str) -> str:\\n module: pdoc.doc.Module = context[\\\"module\\\"]\\n docformat: str = context[\\\"docformat\\\"]\\n return to_markdown(docstring, module, docformat)\",\n \"def docs(session):\\n session.install('-rrequirements-dev.txt')\\n session.install('-e', '.')\\n run_sphinx(session)\",\n \"def generate(self, object=None, replacements=None, source=None):\\n\\n if replacements is None:\\n replacements = []\\n\\n if source:\\n doc_info = source\\n else:\\n docstring = object.__doc__\\n if docstring is None:\\n docstring = 'Not yet documented'\\n\\n doc_info = self.helpers.extract_info(docstring)\\n # print(8, docstring)\\n # print(6, source, bool(source))\\n\\n try:\\n k = list(doc_info.hierarchy.keys())[0]\\n except:\\n k = 'parameter'\\n self.stype = k\\n # print(self.stype)\\n\\n if self.stype in ['class', 'method']:\\n\\n # replacements.append(('{docstring}', doc_info['text']['val'][0]))\\n # (not c.children and True)\\n m = ''.join([c.label for c in doc_info.children if True])\\n # print(m)\\n replacements.append(('{docstring}', m))\\n # else:\\n # doc_info = object\\n # WARNING\\n\\n content = self.template_content[self.stype]\\n for r in replacements:\\n content = content.replace(*r)\\n\\n # print(self.stype)\\n if self.stype == 'method':\\n pass\\n elif self.stype == 'parameter':\\n # param_list = []\\n # print(doc_info.names())\\n # if 'params' in doc_info.names():\\n # print(True)\\n # for k, v in doc_info['params'].items():\\n # k = doc_info.label:\\n # if k[0] in '!':\\n # k = k[1:] + ' [required]'\\n # if k[0] in '~':\\n # k = k[1:] + ' [optional]'\\n #\\n # param_content = generate_section('parameter', v, [('{parameter}', k)])\\n # param_list.append(param_content)\\n content = content.replace('[params]', '\\\\n'.join(param_list))\\n\\n # content = ''\\n # label = doc_info[0]['label']\\n label = doc_info.label\\n\\n if '{ex' in label:\\n examples = []\\n ex_options = label[label.find('{ex'): label.find('}')+1]\\n # print(ex_options)\\n ex_options_ = [float(f) for f in ex_options.split(':')[1][:-1].split(',')]\\n ex_options_ = ex_options_ + [1., 1., 20.][-(3-len(ex_options_)):]\\n print(ex_options_)\\n for l in range(int(ex_options_[0])):\\n bounds = ex_options_[1:3]\\n # if ex_options_[1] % 1. == 0:\\n if ex_options_[1].is_integer():\\n ex = random.randint(*bounds)\\n else:\\n ex = random.uniform(*bounds)\\n\\n examples.append(str(ex))\\n\\n examples = 'Examples: {}'.format('; '.join(['`{}`'.format(e) for e in examples]))\\n label = label.replace(ex_options, examples)\\n doc_info[0]['label'] = label\\n content = content.replace('{label}', label)\\n\\n type_list = []\\n for t in []:\\n # print(t, 't')\\n try:\\n # print('[{}]'.format(','.join(t['type'])))\\n y = [str(v) for v in t['type']]\\n z = '[{}]'.format(','.join(y))\\n print(z)\\n z = z.replace(\\\"'\\\", '\\\"')\\n # type_tags = set(json.loads(z))\\n type_tags = json.loads(z)\\n typestring = parse_tags(type_tags)\\n print(True)\\n except Exception as e:\\n print(e)\\n typestring = ''\\n for req in t['type']:\\n if req in ['int', 'str', 'float', 'bool']:\\n typestring += '`{}`'.format(req)\\n elif req[0] == 'r':\\n if ':' in req:\\n limits = req[1:].split(':')\\n typestring += ' between `{}` and `{}`'.format(*limits)\\n # elif any(c in req for c in '<>')\\n # elif '<' in req:\\n elif any(s in req for s in symbols):\\n typestring += ' {} {}'.format(symbols[req[1]], req[-1])\\n\\n type_list.append('- {}: {}'.format(typestring, t['label']))\\n\\n content = content.replace('[types]', '\\\\n'.join(type_list))\\n\\n # print(doc_info.children)\\n for c in doc_info.children:\\n content += c.generate(template=self.template_content) + '\\\\n'\\n\\n return content\",\n \"def __call__(self, doc):\\n return doc\",\n \"def init_doc(self):\\n raise NotImplementedError()\",\n \"def run(self):\\n name_desc = self.__class__.name_sphinx\\n settings = self.state.document.settings\\n env = settings.env if hasattr(settings, \\\"env\\\") else None\\n docname = None if env is None else env.docname\\n tag = self.options.get('tag', '').strip()\\n n = self.__class__.node_class('')\\n n[\\\"breftag\\\"] = tag\\n n[\\\"brefsort\\\"] = self.options.get('sort', 'title').strip()\\n n[\\\"brefsection\\\"] = self.options.get(\\n 'section', True) in (True, \\\"True\\\", \\\"true\\\", 1, \\\"1\\\")\\n n[\\\"brefcontents\\\"] = self.options.get(\\n 'contents', False) in (True, \\\"True\\\", \\\"true\\\", 1, \\\"1\\\", \\\"\\\", None, \\\"None\\\")\\n n['docname'] = docname\\n if env is not None:\\n targetid = 'index%slist-%s' % (name_desc,\\n env.new_serialno('index%slist' % name_desc))\\n targetnode = nodes.target('', '', ids=[targetid])\\n return [targetnode, n]\\n else:\\n return [n]\",\n \"def show_documentation(self):\\n self.docs = documentation.Documentation()\",\n \"def get_doc_context(self, docname, body, metatags):\\n\\n # TYPO3: remove 'documentation' from end of 'shorttitle'\\n shorttitle = self.globalcontext.get('shorttitle', '')\\n if shorttitle and shorttitle.endswith(' documentation'):\\n shorttitle = shorttitle[0:-14].rstrip()\\n self.globalcontext['shorttitle'] = shorttitle\\n \\n\\n # find out relations\\n # TYPO3: always have order 'previous', 'up', 'next'\\n prev = up = next = None\\n parents = []\\n rellinks = self.globalcontext['rellinks'][:]\\n related = self.relations.get(docname)\\n titles = self.env.titles\\n if related and related[1]:\\n try:\\n prev = {\\n 'link': self.get_relative_uri(docname, related[1]),\\n 'title': self.render_partial(titles[related[1]])['title']\\n }\\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n if related and related[0]:\\n try:\\n up = {\\n 'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']\\n }\\n rellinks.append((related[0], up['title'], 'U', _('up')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n if related and related[2]:\\n try:\\n next = {\\n 'link': self.get_relative_uri(docname, related[2]),\\n 'title': self.render_partial(titles[related[2]])['title']\\n }\\n rellinks.append((related[2], next['title'], 'N', _('next')))\\n except KeyError:\\n next = None\\n while related and related[0]:\\n try:\\n parents.append(\\n {'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']})\\n except KeyError:\\n pass\\n related = self.relations.get(related[0])\\n if parents:\\n parents.pop() # remove link to the master file; we have a generic\\n # \\\"back to index\\\" link already\\n parents.reverse()\\n\\n # title rendered as HTML\\n title = self.env.longtitles.get(docname)\\n title = title and self.render_partial(title)['title'] or ''\\n # the name for the copied source\\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\\n\\n # metadata for the document\\n meta = self.env.metadata.get(docname)\\n\\n # local TOC and global TOC tree\\n self_toc = self.env.get_toc_for(docname, self)\\n toc = self.render_partial(self_toc)['fragment']\\n\\n return dict(\\n parents = parents,\\n prev = prev,\\n next = next,\\n title = title,\\n meta = meta,\\n body = body,\\n metatags = metatags,\\n rellinks = rellinks,\\n sourcename = sourcename,\\n toc = toc,\\n # only display a TOC if there's more than one item to show\\n display_toc = (self.env.toc_num_entries[docname] > 1),\\n )\",\n \"def _builder_inited(app: sphinx.application.Sphinx) -> None:\\n _write_member_documentation_pages(\\n _create_documenter(env=app.env,\\n documenter_cls=sphinx.ext.autodoc.ModuleDocumenter,\\n name='tensorstore'))\",\n \"async def docs(self, ctx):\\n embed = discord.Embed(title = \\\"Documentation\\\", description = \\\"[Click here to visit our documentation!](https://dhb-documentation.readthedocs.io/en/latest/index.html)\\\", color = discord.Color.blurple())\\n await ctx.send(embed = embed)\",\n \"def build_document(self):\\n pass\",\n \"def generate_html(repo_dir, package_dir, module):\\n apidir = os.path.join(repo_dir, 'doc', 'api')\\n print(f\\\"Generating {module} API docs in {apidir!r}\\\")\\n if subprocess.call(['sphinx-apidoc', '-Tef', '-o', apidir,\\n os.path.join(package_dir, module),\\n os.path.join(package_dir, module, 'test'),\\n os.path.join(package_dir, module, 'scripts')]):\\n raise RuntimeError(f'API doc generation failed for {module}')\",\n \"def pydocstyle(context):\\n exec_cmd = \\\"pydocstyle .\\\"\\n run_cmd(context, exec_cmd)\",\n \"def get_documentation(self, css_path=None, base_url=None):\\n if base_url is None:\\n first_key = next(iter(self.conf_doc))\\n conf = self.conf_doc[first_key]\\n else:\\n conf = self.conf_doc[\\\"/\\\" + base_url]\\n\\n return (\\n 200,\\n \\\"\\\"\\\"<!DOCTYPE html>\\n<html xmlns=\\\"http://www.w3.org/1999/xhtml\\\">\\n <head>\\n <title>%s</title>\\n <meta http-equiv=\\\"content-type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width\\\" />\\n <style>%s</style>\\n %s\\n </head>\\n <body>\\n <aside>%s</aside>\\n <main>%s</main>\\n <section id=\\\"operations\\\">%s</section>\\n <footer>%s</footer>\\n </body>\\n</html>\\\"\\\"\\\"\\n % (\\n self.__title(conf),\\n self.__css(),\\n self.__css_path(css_path),\\n self.__sidebar(conf),\\n self.__header(conf),\\n self.__operations(conf),\\n self.__footer(),\\n ),\\n )\",\n \"def process_doxygen(self):\\n if not getattr(self, \\\"doxygen_conf\\\", None):\\n self.generator.bld.fatal(\\\"No doxygen configuration file supplied.\\\")\\n if not isinstance(self.doxygen_conf, Node.Node):\\n self.generator.bld.fatal(\\\"'doxygen_conf' must be a Node.\\\")\\n\\n self.create_task(\\n \\\"doxygen\\\",\\n self.doxygen_conf,\\n cwd=self.bld.path.get_bld().abspath(),\\n output=Context.STDERR,\\n )\",\n \"def generate():\\n local('cd doc && make clean && make html')\",\n \"def doc_apply(doc):\\n\\n def wrapper(func):\\n func.__doc__ = doc\\n return func\\n\\n return wrapper\",\n \"def setup_docs(self):\\n for arg in self.args:\\n self.log.debug(\\\"Processing arg %s\\\" % arg)\\n if isinstance(arg, dexy.doc.Doc) or isinstance(arg, dexy.doc.PatternDoc):\\n doc = arg\\n\\n elif isinstance(arg, list):\\n if not isinstance(arg[0], basestring):\\n raise Exception(\\\"First arg %s should be a string\\\" % arg[0])\\n if not isinstance(arg[1], dict):\\n raise Exception(\\\"Second arg %s should be a dict\\\" % arg[1])\\n\\n if not \\\"*\\\" in arg[0]:\\n doc = dexy.doc.Doc(arg[0], **arg[1])\\n else:\\n # This is a pattern doc or real doc TODO better way to verify?\\n doc = dexy.doc.PatternDoc(arg[0], **arg[1])\\n\\n elif isinstance(arg, basestring):\\n doc = dexy.doc.PatternDoc(arg)\\n\\n else:\\n raise Exception(\\\"unknown arg type %s for arg %s\\\" % (arg.__class__.__name__, arg))\\n\\n doc.wrapper = self\\n doc.setup()\\n\\n self.docs.append(doc)\",\n \"async def create_doc(self, *args, **kwargs):\\n pass\",\n \"def build_docs(open_docs):\\n python_call(\\\"pip\\\", [\\\"install\\\", \\\"src/[docs]\\\"])\\n python_call(\\\"pip\\\", [\\\"install\\\", \\\"-r\\\", \\\"src/requirements.txt\\\"])\\n python_call(\\n \\\"ipykernel\\\", [\\\"install\\\", \\\"--user\\\", \\\"--name=za_covid_map\\\"]\\n )\\n shutil.rmtree(\\\"docs/build\\\", ignore_errors=True)\\n call(\\n [\\n \\\"sphinx-apidoc\\\",\\n \\\"--module-first\\\",\\n \\\"-o\\\",\\n \\\"docs/source\\\",\\n \\\"src/za_covid_map\\\",\\n ]\\n )\\n call([\\\"sphinx-build\\\", \\\"-M\\\", \\\"html\\\", \\\"docs/source\\\", \\\"docs/build\\\", \\\"-a\\\"])\\n if open_docs:\\n docs_page = (Path.cwd() / \\\"docs\\\" / \\\"build\\\" / \\\"html\\\" / \\\"index.html\\\").as_uri()\\n secho(\\\"Opening {}\\\".format(docs_page))\\n webbrowser.open(docs_page)\",\n \"def __doc__(self, ???):\",\n \"def docs(self):\\n self._doc_info = DocumentationURL()\\n self._doc_info.show()\",\n \"def __call__(self, doc: Doc) -> Doc:\\n return doc\",\n \"def __call__(self, doc: Doc) -> Doc:\\n return doc\",\n \"def __init__(self,\\n source_path='./*.py',\\n template_path='./docs/templates/*_template.md',\\n output_path='./docs/documentation.md',\\n ignore=['extra']\\n ):\\n\\n template_files = glob.glob(template_path)\\n # filename = t.split('/')[-1]\\n self.sources = {os.path.basename(s).split('.')[0]: os.path.normpath(s) for s in glob.glob(source_path) if not any(i in s for i in ignore)}\\n self.templates = {os.path.basename(t).split('_')[0]: os.path.normpath(t) for t in template_files}\\n self.output_path = output_path\\n\\n self.template_content = {}\\n for k, v in self.templates.items():\\n path = v\\n with open(path, 'r') as template_file:\\n self.template_content[k] = template_file.read()\\n\\n self.text = ''\\n self.classes = []\\n self.headers = ['Params', 'Returns', 'Attributes']\\n self.hierarchy = [\\n 'class',\\n 'method',\\n 'parameter',\\n 'pinfo',\\n 'extra'\\n ]\\n self.tab_length = 6\",\n \"def get_doc_context(self, docname, body, metatags):\\n\\n # find out relations\\n prev = next = None\\n parents = []\\n rellinks = self.globalcontext['rellinks'][:]\\n related = self.relations.get(docname)\\n # Populate titles with the list of longtitles from the env instead of titles\\n # titles = self.env.titles\\n titles = self.env.longtitles\\n if related and related[2]:\\n try:\\n next = {\\n 'link': self.get_relative_uri(docname, related[2]),\\n 'title': self.render_partial(titles[related[2]])['title']\\n }\\n rellinks.append((related[2], next['title'], 'N', _('next')))\\n except KeyError:\\n next = None\\n if related and related[1]:\\n try:\\n prev = {\\n 'link': self.get_relative_uri(docname, related[1]),\\n 'title': self.render_partial(titles[related[1]])['title']\\n }\\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n while related and related[0]:\\n try:\\n parents.append(\\n {'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']})\\n except KeyError:\\n pass\\n related = self.relations.get(related[0])\\n if parents:\\n parents.pop() # remove link to the master file; we have a generic\\n # \\\"back to index\\\" link already\\n parents.reverse()\\n\\n # title rendered as HTML\\n title = self.env.longtitles.get(docname)\\n title = title and self.render_partial(title)['title'] or ''\\n # the name for the copied source\\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\\n\\n # metadata for the document\\n meta = self.env.metadata.get(docname)\\n\\n # local TOC and global TOC tree\\n self_toc = self.env.get_toc_for(docname, self)\\n toc = self.render_partial(self_toc)['fragment']\\n\\n return dict(\\n parents = parents,\\n prev = prev,\\n next = next,\\n title = title,\\n meta = meta,\\n body = body,\\n metatags = metatags,\\n rellinks = rellinks,\\n sourcename = sourcename,\\n toc = toc,\\n # only display a TOC if there's more than one item to show\\n display_toc = (self.env.toc_num_entries[docname] > 1),\\n )\",\n \"def docs_build(directory, site_name, view=True, assume_yes=False):\\n context = toolkit.load_data_context_with_error_handling(directory)\\n build_docs(context, site_name=site_name, view=view, assume_yes=assume_yes)\\n toolkit.send_usage_message(\\n data_context=context, event=\\\"cli.docs.build\\\", success=True\\n )\",\n \"def generate_docs(root_dir, session):\\n ...\",\n \"def get_documentation(path=\\\"\\\"):\\n return \\\"\\\"\\\"<HTML><head><title>Python Minidoc for \\\"\\\"\\\"+path+\\\"\\\"\\\"</title></head>\\n <body>\\n \\\"\\\"\\\"+get_documentation_body(path)+\\\"\\\"\\\"\\n </body></html>\\\"\\\"\\\"\",\n \"def build_docs(branch):\\n os.chdir(os.path.join(gitdname, 'docs'))\\n sphinx_dir = os.path.join(virtual_dir,'bin')\\n retcode = subprocess.call(\\\"make clean\\\", shell=True)\\n if retcode != 0:\\n os.chdir(dname)\\n msg = \\\"\\\"\\\"Could not clean the html docs for branch %s\\\"\\\"\\\" % branch\\n raise Exception(msg)\\n #NOTE: The python call in the below makes sure that it uses the Python\\n # that is referenced after entering the virtualenv\\n sphinx_call = \\\" \\\".join(['make','html',\\n \\\"SPHINXBUILD=' python /usr/local/bin/sphinx-build'\\\"])\\n activate = os.path.join(virtual_dir, \\\"bin\\\", \\\"activate\\\")\\n activate_virtualenv = \\\". \\\" + activate\\n #NOTE: You have to enter virtualenv in the same call. As soon as the\\n # child process is done, the env variables from activate are lost.\\n # getting the correct env from bin/activate and passing to env is\\n # annoying\\n retcode = subprocess.call(\\\" && \\\".join([activate_virtualenv, sphinx_call]),\\n shell=True,\\n env = {'MATPLOTLIBRC' : # put this in the environment to use local rc\\n '/home/skipper/statsmodels/statsmodels/tools/',\\n # Need this for my openblas setup on my laptop\\n 'LD_LIBRARY_PATH' : os.getenv('LD_LIBRARY_PATH')})\\n\\n if retcode != 0:\\n os.chdir(dname)\\n msg = \\\"\\\"\\\"Could not build the html docs for branch %s\\\"\\\"\\\" % branch\\n raise Exception(msg)\\n os.chdir(dname)\",\n \"def DocString():\\n return\",\n \"def documentation_only():\\n pass\",\n \"def get_doc(self) -> Documentation:\\n r : Documentation = [self.get_doc_string()]\\n r_src = \\\"\\\"\\n if hasattr(self,\\\"_path\\\"): r_src += \\\"locally at '%s'\\\" % (str(self._path))\\n if self.url is not None: r_src += \\\" remote url(orig) '%s'\\\" % (self.url)\\n r_src += \\\" remote url(parsed) '%s'\\\" % (self.git_url.as_string())\\n if self.branch is not None: r_src += \\\" branch '%s'\\\" % (self.branch)\\n r.append(r_src)\\n r_stages = []\\n for (sn,s) in self.stages.items():\\n r_stages.append(sn)\\n pass\\n r_stages.sort()\\n if len(r_stages)>0:\\n r.append(\\\"Stages: %s\\\"%(\\\" \\\".join(r_stages)))\\n pass\\n return r\",\n \"def generate_docs(self, sections):\\n for docs, code in sections:\\n yield docs + code\",\n \"def render_documentation(app_slug: str, model_slug: str):\\n context = {\\\"app_slug\\\": app_slug, \\\"model_slug\\\": model_slug}\\n\\n app = SLUG_MAP.get(app_slug, None)\\n model_choices = (\\n [model for model in app.get_models() if model.get_slug() == model_slug]\\n if app is not None\\n else []\\n )\\n model = model_choices[0] if len(model_choices) == 1 else None\\n\\n fields = {}\\n if model is not None:\\n for field in model.get_open_fields():\\n\\n relation = None\\n if field.is_relation:\\n app_slug = slugify(\\n get_app_name(\\n field.related_model._meta.app_config # pylint: disable=W0212\\n )\\n )\\n relation = {\\n \\\"model\\\": field.related_model.__name__,\\n \\\"doc_link\\\": reverse(\\n \\\"documentation:details\\\", kwargs={\\\"app_slug\\\": app_slug}\\n ),\\n \\\"model_slug\\\": field.related_model.get_slug(),\\n }\\n\\n fields[field.name] = {\\n \\\"name\\\": field.name,\\n \\\"optional\\\": field.null,\\n \\\"default\\\": field.default if field.has_default() else None,\\n \\\"help\\\": convert_string(field.help_text),\\n \\\"type\\\": field.get_internal_type(),\\n \\\"relation\\\": relation,\\n }\\n\\n context[\\\"name\\\"] = model.__name__\\n context[\\\"module\\\"] = model.__module__\\n context[\\\"doc\\\"] = convert_string(model.__doc__, wrap_blocks=True)\\n context[\\\"base\\\"] = str(model.__base__.__name__)\\n # For the rare case where a field name is items, prefer this key val iteration\\n context[\\\"columns\\\"] = [(key, val) for key, val in fields.items()]\\n\\n return context\",\n \"def generate_api_docs(self):\\n if self.API_OUTPUT_DIR:\\n args = [\\n # Put documentation for each module on its own page\\n '-e',\\n # don't create the \\\"modules.rst\\\" file (the table of contents\\n # file) as this is already provided by the package's main rst\\n # file.\\n '-T',\\n # Overwrite existing files\\n '--force',\\n '-o', self.API_OUTPUT_DIR,\\n # the package to generate docs from\\n self.PROJECT_DIR\\n ]\\n excludes = [\\n os.path.join(self.PROJECT_DIR, p)\\n if not os.path.isabs(p) else p\\n for p in self.API_EXCLUDE_DIRS\\n ]\\n apidoc.main(args + excludes)\",\n \"def build_gitbook(certification, certification_dir, output_dir):\\n return certifications_to_gitbook.create_gitbook_documentation(\\n certification=certification,\\n certification_dir=certification_dir,\\n output_path=output_dir\\n )\",\n \"def generate(self):\\n\\n # Write Doxyfile\\n doxyfile_content = DOXYFILE_TEMPLATE.format(\\n name=\\\"wurfapi\\\",\\n output_path=self.output_path,\\n source_path=\\\" \\\".join(self.source_paths),\\n recursive=\\\"YES\\\" if self.recursive else \\\"NO\\\",\\n extra=\\\"\\\",\\n )\\n\\n doxyfile_path = os.path.join(self.output_path, \\\"Doxyfile\\\")\\n with open(doxyfile_path, \\\"w\\\") as doxyfile:\\n\\n doxyfile.write(doxyfile_content)\\n\\n # @todo: Doxygen generates a bunch of warnings. We should\\n # propagate these somehow - if you want to know what\\n # has not been documented etc.\\n result = self.runner.run(\\n command=self.doxygen_executable + \\\" Doxyfile\\\", cwd=self.output_path\\n )\\n\\n # Doxygen reports warnings on stderr. So if we have some output\\n # there raise it.\\n self._suppress_incorrect_warnings(result.stderr)\\n\\n if result.stderr.output and self.warnings_as_error:\\n raise wurfapi.doxygen_error.DoxygenError(result.stderr.output)\\n\\n # The Doxygen XML is written to the 'xml' subfolder of the\\n # output directory\\n return os.path.join(self.output_path, \\\"xml\\\")\",\n \"def generate_code_documentation(self, output_directory: Path, module_to_document: str) -> None:\\n logger.info(\\\"Generating code documentation\\\")\\n pass\",\n \"def task_sphinx():\\n return Task(\\n file_dep=[CONF], actions=[(needs, [\\\"sphinx\\\"])], uptodate=[not CONF.exists()]\\n )\",\n \"def doc_factory(global_config, **local_conf):\\n\\treturn make_app(blueprints.developer_portal, settings.ProductionConfig)\",\n \"def generate_patch_build(self, domain):\\n # TODO change name of def\\n base_path = self.paths[\\\"api_doc_dir\\\"]\\n self.generate_apidoc_patches()\\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\\n patch_generator.filter_for_deleted_apis()\\n\\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\\n\\n output = process.communicate()[0]\\n if output:\\n\\n with open(self.paths[\\\"base_dir\\\"] + \\\"/apidoc.json\\\", 'w') as outfile:\\n apidoc_content = {\\\"url\\\": \\\"https://ib-backend-dev.apigateway.in\\\",\\n \\\"version\\\": \\\"0.0.1\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"name\\\": \\\"iBHubs_backend API Documentation\\\",\\n \\\"title\\\": \\\"iBHubs_backend Documenation\\\"}\\n json.dump(apidoc_content, outfile, indent=4)\\n # by default we assume user is working at no specific branch so we fix\\n # url to default above url as above , then we check if any specific parametr is given\\n # and replace url with required url\\n if domain != '' and domain:\\n with open(self.paths[\\\"apidoc\\\"]) as src_json:\\n apidoc_content = json.load(src_json)\\n apidoc_content['url'] = \\\"https://\\\" + domain\\n with open(self.paths[\\\"apidoc\\\"], 'w') as outfile:\\n json.dump(apidoc_content, outfile, indent=4)\\n try:\\n os.mkdir(\\\"docs\\\")\\n except OSError:\\n pass\\n # the below command is responsible for creating docs\\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\\n '-o', os.path.join(self.base_dir, 'docs'),\\n '-e', 'django_swagger_utils/*',\\n '-e', 'static/*',\\n ], stdout=subprocess.PIPE)\\n print process.communicate()[0]\\n ################################################\\n # hosting apidoc\\n ################################################\\n # obtaining the path of static folder of django-swagger-utils\\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"../..\\\"))\\n # static_folder_path = os.path.join(django_swagger_utils_path, \\\"static\\\")\\n # import shutil\\n # # create a folder apidoc , delete if previously exists\\n # if os.path.exists(os.path.join(static_folder_path, \\\"apidoc\\\")):\\n # shutil.rmtree(os.path.join(static_folder_path, \\\"apidoc\\\"))\\n # apidoc_path = os.path.join(static_folder_path, \\\"apidoc\\\")\\n #\\n # os.mkdir(apidoc_path)\\n\\n # from distutils.dir_util import copy_tree\\n # copydocs from docs to apidoc in swagger utils\\n # try:\\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\\n # except Exception as err:\\n # print err\\n\\n # browse to localhost:<port>/static/apidoc/index.html\\n\\n else:\\n raise CommandError(\\\"Help: Install apidoc: [ sudo npm install -g apidoc ]\\\")\",\n \"def func_doc():\",\n \"def event_html_page_context(app, pagename, templatename, context, doctree):\\n\\n reURL = re.compile('^https?://\\\\S+/$')\\n current_builder = app.builder.name\\n if current_builder == 'html' or current_builder == 'readthedocs':\\n if doctree and doctree.traverse(DiscourseNode):\\n if not app.config.discourse_url:\\n raise DiscourseError('::discourse: directive found, but discourse_url is not set in conf.py')\\n if not reURL.match(app.config.discourse_url):\\n raise DiscourseError('::discourse: directive found, but discourse_url is not set properly in conf.py (must be a valid URL starting with http:// or https:// and ending with trailing slash)')\\n for discourse_node in doctree.traverse(DiscourseNode):\\n context['body'] += \\\"\\\"\\\"<script type='text/javascript'>\\n DiscourseEmbed = { discourseUrl: '%s',\\n topicId: '%s' };\\n (function() {\\n var d = document.createElement('script'); d.type = 'text/javascript'; d.async = true;\\n d.src = DiscourseEmbed.discourseUrl + 'javascripts/embed.js';\\n (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(d);\\n })();\\n </script>\\\"\\\"\\\" % (app.config.discourse_url, discourse_node.get_topic_identifier())\",\n \"def get_test_doc(self, name, doc_string=None):\\n # PARSE OUT THE DOXYGEN SETTINGS FROM THE STRING\\n doc_string = doc_string if doc_string is not None else self._testMethodDoc\\n doc_list = [x.strip().replace('\\\\t', '') for x in doc_string.split('\\\\n') if len(x.strip().replace('\\\\t', '')) > 0]\\n # CREATE DOC DICT OBJECT\\n doc_dict = dict(name=name, title=doc_list[0], bug='', tags=[])\\n for val in doc_list[1:]:\\n if '@test' in val:\\n doc_dict['test'] = val[5:]\\n elif '@arg' in val:\\n doc_dict['tags'] = [x.lower() for x in val[4:].split()]\\n elif '@attention' in val:\\n doc_dict['priority'] = val[10:]\\n elif '@author' in val:\\n doc_dict['author'] = val[7:]\\n elif '@date' in val:\\n doc_dict['date'] = val[5:]\\n elif '@bug' in val:\\n doc_dict['bug'] = val[4:].strip()\\n elif '@version' in val:\\n doc_dict['version'] = int(val[8:].replace(\\\".\\\", \\\"\\\"))\\n elif '@deprecated' in val:\\n doc_dict['deprecated'] = True\\n elif '@note' in val:\\n env_result = re.findall('ENV=(\\\\w+)', val.upper())\\n if len(env_result) > 0:\\n doc_dict['datacenters'] = env_result\\n env_not = re.findall('ENV!=(\\\\w+)', val.upper())\\n if len(env_not) > 0:\\n doc_dict['no_environment'] = env_not\\n priority = re.findall('priority=(\\\\d)', val.lower())\\n if len(priority) > 0:\\n doc_dict['priority'] = priority[0]\\n else:\\n doc_dict['note'] = val[5:]\\n # CHECK IF TITLE AND NOTE NOT IN DOC_DICT\\n if 'title' not in doc_dict:\\n doc_dict['Title'] = 'TEST DOCUMENTATION DOES NOT INCLUDE THE TEST TITLE'\\n if 'test' not in doc_dict:\\n doc_dict['Test'] = 'TEST DOCUMENTATION DOES NOT INCLUDE TEST DESCRIPTION'\\n self.doc_dict = doc_dict\",\n \"def docstrings(param1, param2):\\n return \\\"example string\\\"\",\n \"def sphinx(name, options='', dirname='sphinx-rootdir',\\n theme='pyramid', automake_sphinx_options='',\\n split=False):\\n if name.endswith('.do.txt'):\\n name = name.replace('.do.txt', '')\\n\\n if name.endswith('.do'):\\n name = name.replace('.do','')\\n\\n # Compile source\\n cmd = 'doconce format sphinx %(name)s %(options)s ' % vars()\\n system(cmd)\\n\\n if split:\\n cmd = 'doconce split_rst %(name)s' % vars()\\n\\n # Create sphinx directory\\n cmd = 'doconce sphinx_dir theme=%(theme)s %(name)s' % vars()\\n system(cmd)\\n\\n # Compile sphinx\\n cmd = 'python automake_sphinx.py %(automake_sphinx_options)s' % vars()\\n system(cmd)\",\n \"def build(working_directory, configuration):\\n\\n # Copy README.rst to docs/temp/README.html\\n # Doxygen may not create the output folder, ensure it exists.\\n\\n temp_dir = os.path.join(working_directory, \\\"temp\\\")\\n create_folder_if_needed(temp_dir)\\n\\n # Needed for dot generated docs\\n create_folder_if_needed(os.path.join(temp_dir, \\\"images\\\"))\\n\\n # Process all the .dot files\\n for item in os.listdir(working_directory):\\n\\n # Process the .dot files\\n if _DOT_MATCH.match(item):\\n # Call dot to create the files\\n run_command(\\n (\\\"dot\\\", \\\"-Tpng\\\", item, \\\"-otemp{0}images{0}{1}.png\\\".format(\\n os.sep, item[:-4])),\\n working_dir=working_directory)\\n\\n\\n # Get the input and output file names\\n source = os.path.join(os.path.dirname(working_directory), \\\"README.rst\\\")\\n dest = os.path.join(temp_dir, \\\"README.html\\\")\\n\\n # Was the file already created and newer than the source?\\n if is_source_newer(source, dest):\\n\\n # Load pandoc if needed to do the conversion\\n pypandoc.ensure_pandoc_installed(delete_installer=True)\\n pypandoc.convert_file(source, to=\\\"html\\\", outputfile=dest)\\n return 0\",\n \"def main():\\n sys.argv.extend(('--linklint-dir', THIS_DIR,\\n '--source-dir', os.path.join(THIS_DIR, 'src'),\\n '--project-dir', PROJECT_DIR))\\n return docs.generate_docs.main()\",\n \"def gen_example_rst(example):\\n if not example:\\n return \\\"\\\"\\n res = \\\"\\\"\\\"**Example**\\n\\n.. literalinclude:: /samples/{example}/CMakeLists.txt\\n :language: cmake\\n\\n\\\"\\\"\\\"\\n return res.format(example=example)\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def StartDoc(*args, **kwargs):\\n return _gdi_.GraphicsContext_StartDoc(*args, **kwargs)\",\n \"def makeDocFile(self):\\n\\n f_out = \\\"%s/%s-doc.php\\\" % (self.dir_out, self.project_id)\\n version = max(self.versions)\\n\\n with open(f_out, 'w') as f:\\n f.write(\\\"<!DOCTYPE html>\\\\n\\\" \\\\\\n \\\"<html xmlns=\\\\\\\"http://www.w3.org/1999/xhtml\\\\\\\">\\\\n\\\" \\\\\\n \\\"<head>\\\\n\\\" \\\\\\n \\\"<meta http-equiv=\\\\\\\"Content-Type\\\\\\\" content=\\\\\\\"text/html; charset=utf-8\\\\\\\"/>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"<title>Kit&Pack − Ultimate Power Booster</title>\\\\n\\\" \\\\\\n \\\"<link rel=\\\\\\\"shortcut icon\\\\\\\" type=\\\\\\\"image/png\\\\\\\" href=\\\\\\\"../favicon.png\\\\\\\"/>\\\" \\\\\\n \\\"<link rel=\\\\\\\"stylesheet\\\\\\\" type=\\\\\\\"text/css\\\\\\\" href=\\\\\\\"../css/doc-2.css\\\\\\\" />\\\\n\\\"\\n \\\"\\\\n\\\" \\\\\\n \\\"</head>\\\\n\\\" \\\\\\n \\\"<body>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"<h1>Ultimate Power Booster</h1>\\\" \\\\\\n \\\"\\\\n\\\")\\n\\n # Write a list of other versions of the documentation\\n f.write(\\\"<p>Versions de cette documentation.</p>\\\\n\\\")\\n f.write(\\\"<ul>\\\\n\\\")\\n for v in self.versions:\\n f.write(\\\"\\\\t<li><a href=\\\\\\\"%s.php\\\\\\\">%s</a></li>\\\\n\\\" % (\\n v, v))\\n f.write(\\\"</ul>\\\\n\\\\n\\\")\\n\\n f.write(\\\"<?php\\\\n\\\" \\\\\\n \\\"include(\\\\\\\"%s.php\\\\\\\")\\\\n\\\" \\\\\\n \\\"?>\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"</body>\\\\n\\\" \\\\\\n \\\"</html>\\\" % (version))\",\n \"def test_buildWithPolicy(self):\\n stdout = StringIO()\\n self.patch(sys, 'stdout', stdout)\\n docstring = \\\"text in docstring\\\"\\n\\n projectRoot = FilePath(self.mktemp())\\n packagePath = projectRoot.child(\\\"twisted\\\")\\n packagePath.makedirs()\\n packagePath.child(\\\"__init__.py\\\").setContent(\\n \\\"def foo():\\\\n\\\"\\n \\\" '%s'\\\\n\\\" % (docstring,))\\n packagePath.child(\\\"_version.py\\\").setContent(\\n genVersion(\\\"twisted\\\", 1, 0, 0))\\n outputPath = FilePath(self.mktemp())\\n\\n script = BuildAPIDocsScript()\\n script.buildAPIDocs(projectRoot, outputPath)\\n\\n indexPath = outputPath.child(\\\"index.html\\\")\\n self.assertTrue(\\n indexPath.exists(),\\n \\\"API index %r did not exist.\\\" % (outputPath.path,))\\n self.assertIn(\\n '<a href=\\\"http://twistedmatrix.com/\\\">Twisted</a>',\\n indexPath.getContent(),\\n \\\"Project name/location not in file contents.\\\")\\n\\n twistedPath = outputPath.child(\\\"twisted.html\\\")\\n self.assertTrue(\\n twistedPath.exists(),\\n \\\"Package documentation file %r did not exist.\\\"\\n % (twistedPath.path,))\\n self.assertIn(\\n docstring, twistedPath.getContent(),\\n \\\"Docstring not in package documentation file.\\\")\\n #Here we check that it figured out the correct version based on the\\n #source code.\\n self.assertIn(\\n '<a href=\\\"http://twistedmatrix.com/trac/browser/tags/releases/'\\n 'twisted-1.0.0/twisted\\\">View Source</a>',\\n twistedPath.getContent())\\n\\n self.assertEqual(stdout.getvalue(), '')\",\n \"def makedocs(projectfolder):\\n featuremodel_path = path.join(projectfolder, \\\"productline\\\", \\\"model.xml\\\")\\n configs_path = path.join(projectfolder, \\\"productline\\\", \\\"configs\\\")\\n bddfeatures_path = path.join(projectfolder, \\\"bddfeatures\\\")\\n testreports_path = path.join(projectfolder, \\\"testreports\\\")\\n\\n fmparser = parsers.FeatureModelParser()\\n resultsparser = parsers.TestResultsParser()\\n feature_tree_renderer = ftrenderer.FeatureTreeRenderer()\\n\\n docs_dir = path.join(projectfolder, \\\"docs/generated\\\")\\n if path.exists(docs_dir):\\n shutil.rmtree(docs_dir)\\n makedirs(docs_dir)\\n\\n lektor_templates_path = \\\"doc_templates\\\"\\n utilities.sed_inplace(\\n path.join(lektor_templates_path, \\\"aplet.lektorproject\\\"),\\n r'<<PROJECT>>',\\n CONFIG[\\\"project_name\\\"])\\n\\n products = {}\\n product_names = get_product_names_from_configs_path(configs_path)\\n for product_name in product_names:\\n productconfig_filepath = path.join(projectfolder, \\\"productline/configs\\\", product_name + \\\".config\\\")\\n product_html_report_name = \\\"report{0}.html\\\".format(product_name)\\n product_html_results_src = path.join(testreports_path, product_html_report_name)\\n product_xml_report_name = \\\"report{0}.xml\\\".format(product_name)\\n product_xml_results_src = path.join(testreports_path, product_xml_report_name)\\n\\n with open(productconfig_filepath, \\\"r\\\") as productconfig_file:\\n products[product_name] = {}\\n products[product_name]['features'] = [feature.strip() for feature in productconfig_file.readlines()]\\n\\n current_product_lektor_dir = path.join(lektor_templates_path, \\\"content/products\\\", product_name)\\n if not path.exists(current_product_lektor_dir):\\n makedirs(current_product_lektor_dir)\\n\\n product_filepath = path.join(current_product_lektor_dir,\\\"contents.lr\\\")\\n shutil.copyfile(path.join(lektor_templates_path, \\\"helpers/product_contents.lr\\\"), product_filepath)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_product_from_file(product_xml_results_src)\\n configparser = parsers.ProductConfigParser(feature_model.root_feature.name)\\n product_features = configparser.parse_config(productconfig_filepath)\\n feature_model.trim_based_on_config(product_features)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(current_product_lektor_dir, \\\"feature_model\\\")\\n\\n utilities.sed_inplace(product_filepath, r'<<PRODUCT>>', product_name)\\n product_test_status = feature_model.root_feature.test_status\\n utilities.sed_inplace(product_filepath, \\\"<<TEST_STATUS>>\\\", product_test_status.name)\\n\\n # Copy test run html report to generated docs\\n if path.exists(product_html_results_src):\\n shutil.copyfile(product_html_results_src, path.join(current_product_lektor_dir, product_html_report_name))\\n\\n click.echo(\\\"- Generating feature model SVG...\\\")\\n click.echo(featuremodel_path)\\n\\n feature_model = fmparser.parse_from_file(featuremodel_path)\\n gherkin_pieces = ftrenderer.gherkin_pieces_grouped_by_featurename(bddfeatures_path)\\n gherkin_piece_test_statuses = resultsparser.get_gherkin_piece_test_statuses_for_dir(testreports_path)\\n feature_model.add_gherkin_pieces(gherkin_pieces)\\n feature_model.calculate_test_statuses(gherkin_piece_test_statuses)\\n\\n feature_tree_renderer.build_graphviz_graph(feature_model.root_feature)\\n feature_tree_renderer.render_as_svg(path.join(lektor_templates_path, \\\"content/\\\"), \\\"feature_model\\\")\\n\\n click.echo(\\\"- Building site\\\")\\n lektor_cmd = [\\\"lektor\\\", \\\"--project\\\", lektor_templates_path, \\\"build\\\", \\\"-O\\\", path.abspath(docs_dir)]\\n click.echo(\\\"Running: \\\" + subprocess.list2cmdline(lektor_cmd))\\n subprocess.call(lektor_cmd)\\n\\n product_map_renderer = mapbuilder.ProductMapRenderer()\\n productline_generated_filepath = path.join(docs_dir, \\\"index.html\\\")\\n html = product_map_renderer.get_productmap_html(feature_model, products)\\n utilities.sed_inplace(productline_generated_filepath, r'<<PRODUCTMAP>>', html)\",\n \"def test_build(self):\\n stdout = StringIO()\\n self.patch(sys, 'stdout', stdout)\\n\\n projectName = \\\"Foobar\\\"\\n packageName = \\\"quux\\\"\\n projectURL = \\\"scheme:project\\\"\\n sourceURL = \\\"scheme:source\\\"\\n docstring = \\\"text in docstring\\\"\\n privateDocstring = \\\"should also appear in output\\\"\\n\\n inputPath = FilePath(self.mktemp()).child(packageName)\\n inputPath.makedirs()\\n inputPath.child(\\\"__init__.py\\\").setContent(\\n \\\"def foo():\\\\n\\\"\\n \\\" '%s'\\\\n\\\"\\n \\\"def _bar():\\\\n\\\"\\n \\\" '%s'\\\" % (docstring, privateDocstring))\\n\\n outputPath = FilePath(self.mktemp())\\n outputPath.makedirs()\\n\\n builder = APIBuilder()\\n builder.build(projectName, projectURL, sourceURL, inputPath, outputPath)\\n\\n indexPath = outputPath.child(\\\"index.html\\\")\\n self.assertTrue(\\n indexPath.exists(),\\n \\\"API index %r did not exist.\\\" % (outputPath.path,))\\n self.assertIn(\\n '<a href=\\\"%s\\\">%s</a>' % (projectURL, projectName),\\n indexPath.getContent(),\\n \\\"Project name/location not in file contents.\\\")\\n\\n quuxPath = outputPath.child(\\\"quux.html\\\")\\n self.assertTrue(\\n quuxPath.exists(),\\n \\\"Package documentation file %r did not exist.\\\" % (quuxPath.path,))\\n self.assertIn(\\n docstring, quuxPath.getContent(),\\n \\\"Docstring not in package documentation file.\\\")\\n self.assertIn(\\n '<a href=\\\"%s/%s\\\">View Source</a>' % (sourceURL, packageName),\\n quuxPath.getContent())\\n self.assertIn(\\n '<a href=\\\"%s/%s/__init__.py#L1\\\" class=\\\"functionSourceLink\\\">' % (\\n sourceURL, packageName),\\n quuxPath.getContent())\\n self.assertIn(privateDocstring, quuxPath.getContent())\\n\\n # There should also be a page for the foo function in quux.\\n self.assertTrue(quuxPath.sibling('quux.foo.html').exists())\\n\\n self.assertEqual(stdout.getvalue(), '')\",\n \"def build(_):\",\n \"async def handle_doc(self, request: web.Request) -> web.Response:\\n spec = request.app[\\\"spec\\\"]\\n spec_url = request.app.router[\\\"openapi_spec\\\"].url_for()\\n title = spec.info.title\\n html = f\\\"\\\"\\\"\\n <!DOCTYPE html>\\n <html>\\n <head>\\n <title>{title}</title>\\n <!-- needed for adaptive design -->\\n <meta charset=\\\"utf-8\\\"/>\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1\\\">\\n \\\"\\\"\\\"\\n if self.font:\\n html += f\\\"\\\"\\\"\\n <link href=\\\"https://fonts.googleapis.com/css?{self.font}\\\" rel=\\\"stylesheet\\\">\\n \\\"\\\"\\\"\\n html += f\\\"\\\"\\\"\\n <link rel=\\\"shortcut icon\\\" href=\\\"{self.favicon_url}\\\">\\n <!--\\n ReDoc doesn't change outer page styles\\n -->\\n <style>\\n body {{\\n margin: 0;\\n padding: 0;\\n }}\\n </style>\\n </head>\\n <body>\\n <redoc spec-url=\\\"{spec_url}\\\"></redoc>\\n <script src=\\\"{self.redoc_js_url}\\\"> </script>\\n </body>\\n </html>\\n \\\"\\\"\\\"\\n return web.Response(text=html, content_type=\\\"text/html\\\")\",\n \"def get_documentation():\\n return send_file(base_dir / \\\"static/documentation.html\\\", \\\"text/html; charset=UTF-8\\\")\",\n \"def getDoc(self):\\r\\n return self.__doc__\",\n \"def do_docs(self, path):\\n print(\\\"scaraping documentation\\\")\\n for p in path.glob(\\\"**/*\\\"):\\n if p.is_file():\\n parts = p.relative_to(path).parts\\n if parts[-1].endswith(\\\"rst\\\"):\\n data = tsparse(p.read_bytes())\\n blob = DocBlob()\\n blob.arbitrary = data\\n blob.content = {}\\n\\n blob.ordered_sections = []\\n blob.item_file = None\\n blob.item_line = None\\n blob.item_type = None\\n blob.aliases = []\\n blob.example_section_data = Section()\\n blob.see_also = []\\n blob.signature = None\\n blob.references = None\\n blob.refs = []\\n\\n self.docs[parts] = json.dumps(blob.to_json(), indent=2)\\n else:\\n pass\\n # data = p.read_bytes()\",\n \"def main():\\n\\n return redirect('/apidocs')\",\n \"def _rapidoc(request: HttpRequest) -> HttpResponse:\\n return render(request, 'rapidoc.html', {\\n 'schema': reverse('api:v2:schema'),\\n })\",\n \"def _add_doc(func, doc):\\n func.__doc__ = doc\",\n \"def build_pages(ctx, show=False):\\n\\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\\n import pages\\n import webbrowser\\n\\n # Update all readmes first\\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\\n for line in lines:\\n print(subprocess.getoutput(['invoke', line]))\\n\\n pages.build(True, False)\\n if show:\\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))\",\n \"def html():\\n builtdocs = path(\\\"docs\\\") / options.sphinx.builddir / \\\"html\\\"\\n destdir = path(PACKAGE) / \\\"docs\\\"\\n destdir.rmtree()\\n builtdocs.move(destdir)\",\n \"def __buildDocumentClassDocString():\\n\\n # build a dictionary of tags and their descriptions, seems a little over\\n # the top, but keeps all the information in one place\\n tagsStrings = {\\n \\\"comment\\\" : \\\"Define the comment string\\\",\\n \\\"define\\\" : \\\"Define the symbol name for #define's\\\",\\n \\\"info\\\" : \\\"Information string, to end up in the 'info' output\\\",\\n \\\"instance\\\" : \\\"Instance name\\\",\\n \\\"matlabRoot\\\" : \\\"Name of variable used by the matlab output\\\",\\n \\\"members\\\" : \\\"List of symbols, which are going to be children of this symbol\\\",\\n \\\"name\\\" : \\\"Name of this symbol\\\",\\n \\\"size\\\" : \\\"Size of this symbol, i.e. indicate it is an array\\\",\\n \\\"subtype\\\" : \\\"Define the actual type of general symbol\\\",\\n \\\"symbol\\\" : \\\"Define a symbol, either a top level entity a child in a members\\\",\\n \\\"test\\\" : \\\"Define the preprocessor test\\\",\\n \\\"text\\\" : \\\"Text to put into a banner symbol\\\",\\n \\\"title\\\" : \\\"Set the overall document title\\\",\\n \\\"value\\\" : \\\"Define a value for this symbol\\\",\\n \\\"valuesRequired\\\" : \\\"Does the enumeration allow automatic value assignment in entries\\\",\\n }\\n # build the list of classes\\n classes = dict(filter(lambda (k,v): type(v) == types.ClassType, globals().iteritems()))\\n (tagsUsed, optionsUsed) = buildKeys(classes)\\n\\n # build the string we are going to add to the document class\\n s = \\\"Document class that represents the XML document and contains the data.\\\\n\\\\n\\\"\\n s += \\\"Available tags:\\\\n\\\"\\n\\n for tag in tagsStrings:\\n try:\\n used = \\\" Required by : %s\\\\n\\\" % (\\\", \\\".join(tagsUsed[tag]))\\n except KeyError:\\n used = \\\"\\\"\\n try:\\n opts = \\\" Optional for: %s\\\\n\\\" % (\\\", \\\".join(optionsUsed[tag]))\\n except KeyError:\\n opts = \\\"\\\"\\n s += \\\" %s\\\\n %s\\\\n %s\\\\n\\\\n%s%s\\\\n\\\" % (tag, \\\"-\\\"*len(tag), tagsStrings[tag], used, opts)\\n\\n return s\",\n \"def Init(self, *args):\\n return _XCAFDoc.XCAFDoc_DocumentTool_Init(self, *args)\",\n \"def store_documentation(self, file_path, *args, **dargs):\\n pass\",\n \"def _call_build(*, build, out_dir):\\n with tempfile.TemporaryDirectory(\\n dir=os.environ.get(\\\"TEST_TMPDIR\\\"),\\n prefix=\\\"doc_builder_temp_\\\") as temp_dir:\\n return build(out_dir=out_dir, temp_dir=temp_dir)\",\n \"def _get_doc(self, name):\\r\\n doc = \\\"No documentation for %s\\\" % name\\r\\n\\r\\n engine = self._engine\\r\\n if not engine:\\r\\n msg = \\\"Session is not open\\\"\\r\\n raise Oct2PyError(msg)\\r\\n doc = engine.eval('help(\\\"%s\\\")' % name, silent=True)\\r\\n\\r\\n if \\\"syntax error:\\\" in doc.lower():\\r\\n raise Oct2PyError(doc)\\r\\n\\r\\n if \\\"error:\\\" in doc.lower():\\r\\n doc = engine.eval('type(\\\"%s\\\")' % name, silent=True)\\r\\n doc = \\\"\\\\n\\\".join(doc.splitlines()[:3])\\r\\n\\r\\n default = self.feval.__doc__\\r\\n default = \\\" \\\" + default[default.find(\\\"func_args:\\\") :] # type:ignore\\r\\n default = \\\"\\\\n\\\".join([line[8:] for line in default.splitlines()])\\r\\n\\r\\n doc = \\\"\\\\n\\\".join(doc.splitlines())\\r\\n doc = \\\"\\\\n\\\" + doc + \\\"\\\\n\\\\nParameters\\\\n----------\\\\n\\\" + default\\r\\n doc += \\\"\\\\n**kwargs - Deprecated keyword arguments\\\\n\\\\n\\\"\\r\\n doc += \\\"Notes\\\\n-----\\\\n\\\"\\r\\n doc += \\\"Keyword arguments to dynamic functions are deprecated.\\\\n\\\"\\r\\n doc += \\\"The `plot_*` kwargs will be ignored, but the rest will\\\\n\\\"\\r\\n doc += \\\"used as key - value pairs as in version 3.x.\\\\n\\\"\\r\\n doc += \\\"Use `set_plot_settings()` for plot settings, and use\\\\n\\\"\\r\\n doc += \\\"`func_args` directly for key - value pairs.\\\"\\r\\n return doc\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7200595","0.71286154","0.70953643","0.69826937","0.67844534","0.6753231","0.6731056","0.67097837","0.6688072","0.6656818","0.65566325","0.65320677","0.6452669","0.6432759","0.6430928","0.6357106","0.63557726","0.631642","0.63006896","0.62424266","0.62375325","0.6211397","0.6198723","0.6170702","0.6170702","0.61522067","0.61489975","0.6144311","0.61308306","0.6097766","0.6062149","0.6036565","0.60079235","0.5998854","0.59970546","0.59960353","0.59785897","0.5969715","0.5967417","0.59647214","0.59646857","0.59627676","0.5945802","0.59447193","0.5923643","0.5918207","0.5903975","0.5889188","0.5880862","0.5864151","0.5864151","0.5862079","0.5846353","0.583003","0.58106965","0.5782918","0.5762513","0.5759547","0.5752073","0.57492155","0.57478505","0.5747382","0.57394284","0.57254666","0.5715724","0.56957203","0.5685425","0.56847245","0.5676367","0.56753004","0.567479","0.5659838","0.5656247","0.56458175","0.563867","0.5625653","0.562365","0.56180406","0.56180406","0.56180406","0.5600232","0.55906266","0.559013","0.55875045","0.55775297","0.5561959","0.55608875","0.55594784","0.5549923","0.5548966","0.55464303","0.5540626","0.5539404","0.5537488","0.5525952","0.5513292","0.55117166","0.5511426","0.5509051","0.5505979"],"string":"[\n \"0.7200595\",\n \"0.71286154\",\n \"0.70953643\",\n \"0.69826937\",\n \"0.67844534\",\n \"0.6753231\",\n \"0.6731056\",\n \"0.67097837\",\n \"0.6688072\",\n \"0.6656818\",\n \"0.65566325\",\n \"0.65320677\",\n \"0.6452669\",\n \"0.6432759\",\n \"0.6430928\",\n \"0.6357106\",\n \"0.63557726\",\n \"0.631642\",\n \"0.63006896\",\n \"0.62424266\",\n \"0.62375325\",\n \"0.6211397\",\n \"0.6198723\",\n \"0.6170702\",\n \"0.6170702\",\n \"0.61522067\",\n \"0.61489975\",\n \"0.6144311\",\n \"0.61308306\",\n \"0.6097766\",\n \"0.6062149\",\n \"0.6036565\",\n \"0.60079235\",\n \"0.5998854\",\n \"0.59970546\",\n \"0.59960353\",\n \"0.59785897\",\n \"0.5969715\",\n \"0.5967417\",\n \"0.59647214\",\n \"0.59646857\",\n \"0.59627676\",\n \"0.5945802\",\n \"0.59447193\",\n \"0.5923643\",\n \"0.5918207\",\n \"0.5903975\",\n \"0.5889188\",\n \"0.5880862\",\n \"0.5864151\",\n \"0.5864151\",\n \"0.5862079\",\n \"0.5846353\",\n \"0.583003\",\n \"0.58106965\",\n \"0.5782918\",\n \"0.5762513\",\n \"0.5759547\",\n \"0.5752073\",\n \"0.57492155\",\n \"0.57478505\",\n \"0.5747382\",\n \"0.57394284\",\n \"0.57254666\",\n \"0.5715724\",\n \"0.56957203\",\n \"0.5685425\",\n \"0.56847245\",\n \"0.5676367\",\n \"0.56753004\",\n \"0.567479\",\n \"0.5659838\",\n \"0.5656247\",\n \"0.56458175\",\n \"0.563867\",\n \"0.5625653\",\n \"0.562365\",\n \"0.56180406\",\n \"0.56180406\",\n \"0.56180406\",\n \"0.5600232\",\n \"0.55906266\",\n \"0.559013\",\n \"0.55875045\",\n \"0.55775297\",\n \"0.5561959\",\n \"0.55608875\",\n \"0.55594784\",\n \"0.5549923\",\n \"0.5548966\",\n \"0.55464303\",\n \"0.5540626\",\n \"0.5539404\",\n \"0.5537488\",\n \"0.5525952\",\n \"0.5513292\",\n \"0.55117166\",\n \"0.5511426\",\n \"0.5509051\",\n \"0.5505979\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5954264"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":9460,"cells":{"query":{"kind":"string","value":"Normalize the batch data, use coordinates of the block centered at origin,"},"document":{"kind":"string","value":"def normalize_data(batch_data):\n B, N, C = batch_data.shape\n normal_data = np.zeros((B, N, C))\n for b in range(B):\n pc = batch_data[b]\n centroid = np.mean(pc, axis=0)\n pc = pc - centroid\n m = np.max(np.sqrt(np.sum(pc ** 2, axis=1)))\n pc = pc / m\n normal_data[b] = pc\n return normal_data"},"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 _normalize(self, dataset):\n if self.max is None: # if we are normalizing the training set\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\n for row in dataset.index: # for each row in dataset\n for col in self.features: # for each feature in the instance (exclude target)\n dataset.at[row, col] = (dataset.at[row, col] - self.min[col]) / (self.max[col] - self.min[col]) if col != \"Bias\" else 1","def normalize_data(data=None):\n # Data pre-processing\n n = data.shape[0]\n for i in range(n):\n xx = data[i,:,:]\n xx -= np.mean(xx) # Centering in 0\n xx /= np.linalg.norm(xx) # Normalizing to 1\n data[i] = xx # Affect value\n return data","def normalize(self):\n self._data /= self.norm()","def normalise(self):\n for at in self.atoms:\n if at.x < 0. :\n at.x = self.coordx + at.x\n if at.y < 0. :\n at.y = self.coordy + at.y\n if at.z < 0. :\n at.z = self.coordz + at.z","def norm(self):\r\n old_origin = np.array(self.origin)\r\n self.origin = [0, 0, 0]\r\n old_origin[0] = old_origin[0] / self.x[0]\r\n old_origin[1] = old_origin[1] / self.y[1]\r\n old_origin[2] = old_origin[2] / self.z[2]\r\n self.data = ndimage.shift(self.data, -old_origin, mode='wrap')","def normalize(batch_img: np.ndarray) -> np.ndarray:\n batch_img = batch_img.astype('float32')\n return batch_img / 127.5 - 1","def normalize(self):\n d = learning_utils.convert_data_to_2d(self._data)\n d = learning_utils.normalize_2d(d)\n self._data = learning_utils.convert_data_to_1d(d)","def set_normalization(self, dataloader):\n mean = 0\n square = 0\n for (data_in, _) in dataloader:\n mean += data_in.mean()\n square += data_in.pow(2).mean()\n\n mean /= len(dataloader)\n square /= len(dataloader)\n std = np.sqrt(square - mean ** 2)\n\n # The input data should be roughly normally distributed after\n # passing through net_fixed.\n self.scale_in.bias.data.fill_(- mean / std)\n self.scale_in.weight.data.fill_(1 / std)","def BatchNormalize(S):\n mu = np.mean(S, axis=0)\n v = np.mean((S-mu)**2, axis=0)\n S = (S - mu) / np.sqrt(v + epsilon)\n return S","def normalize_wrt_x(self):\n\n x_min = min(self.x)\n x_max = max(self.x)\n y_min = min(self.y)\n\n x_range = x_max - x_min\n\n x = np.array(self.x)\n y = np.array(self.y)\n x -= x_min\n y -= y_min\n x = x / float(x_range)\n y = y / float(x_range)\n\n self.x = x.tolist()\n self.y = y.tolist()","def normalize_batch(batch, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\n # normalize using imagenet mean and std\n batch = batch.clone()\n mean = torch.tensor(mean).view(-1, 1, 1)\n std = torch.tensor(std).view(-1, 1, 1)\n # if your image data is scaled to scale 0-255, uncomment the line below\n # batch.div_(255.0)\n return (batch - mean) / std","def normalize_data(self):\n\t\tfull_matrix = self.balance_clases()\n\t\ttexture_matrix = Normalizer().fit_transform(X=full_matrix[:,range(0,24)])\n\n\t\treturn texture_matrix","def normalize(dataset):\n minVals = dataset.min(axis=0)\n maxVals = dataset.max(axis=0)\n factors = maxVals-minVals\n num = dataset.shape[0]\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \n return norm_data","def normalize_data(img):\n nor = np.linalg.norm(img, axis = 1)\n nor = np.reshape(nor, (len(img), 1))\n img = np.divide(img, nor)\n return img","def normalize(self):\r\n max = np.amax(self.matrix)\r\n min = np.amin(self.matrix)\r\n\r\n self.matrix = ((self.matrix - min) / (max - min))","def _normalize(self, x):\n # TODO: imagenet normalization\n\n return x","def normalize_dataset(self):","def normalize(self):\n total = 0.0\n for i in range(0,self.npoints):\n total+=self.y[i]*self._dx\n for i in range(0,self.npoints):\n self.y[i]/=total\n return","def normalize(shape):\n s = shape\n matrix = Shape.get_matrix(s.get_vector())\n norm_x = math.sqrt(sum(matrix[:, 0] ** 2))\n norm_y = math.sqrt(sum(matrix[:, 1] ** 2))\n for pt in s.pts:\n pt.x /= norm_x\n pt.y /= norm_y\n return s","def center_normalize(x):\n return (x - K.mean(x)) / K.std(x)","def center_normalize(x):\n return (x - K.mean(x)) / K.std(x)","def _normalize_coordinates(\n target_size: int, coords: np.ndarray, original_size: Tuple[int, int], is_bounding_box=False\n) -> np.ndarray:\n old_height, old_width = original_size\n\n scale = target_size * 1.0 / max(old_height, old_width)\n new_height, new_width = old_height * scale, old_width * scale\n new_width = int(new_width + 0.5)\n new_height = int(new_height + 0.5)\n\n coords = deepcopy(coords).astype(float)\n\n if is_bounding_box:\n coords = coords.reshape(-1, 2, 2)\n\n coords[..., 0] = coords[..., 0] * (new_width / old_width)\n coords[..., 1] = coords[..., 1] * (new_height / old_height)\n\n if is_bounding_box:\n coords = coords.reshape(-1, 4)\n\n return coords","def normalize(self) -> \"CharacterizationPixel\":\n return replace(\n self,\n data=self.data/self.norm,\n mean=self.mean/self.norm,\n norm=np.ones_like(self.norm),\n )","def normalize_data(self):\n self.x_mean, self.x_std = du.get_mean_std(self.x_train)\n self.x_train = du.normalize(self.x_train, self.x_mean, self.x_std)\n if self.x_test is not None and self.y_test is not None:\n self.x_test = du.normalize(self.x_test, self.x_mean, self.x_std)\n self.normalized_data = True","def convert_batch_norm(g, op, block):\n\n ipt_name = op.input(\"X\")[0]\n scale_name = op.input(\"Scale\")[0]\n bias_name = op.input(\"Bias\")[0]\n mean_name = op.input(\"Mean\")[0]\n variance_name = op.input(\"Variance\")[0]\n epsilon = op.attr(\"epsilon\")\n out = _op.nn.batch_norm(\n g.get_node(ipt_name),\n g.get_node(scale_name),\n g.get_node(bias_name),\n g.get_node(mean_name),\n g.get_node(variance_name),\n epsilon=epsilon,\n )\n g.add_node(op.output(\"Y\")[0], out[0])","def centerMeanAndNormalize(df):\n return minMax(df - df.mean(axis=0))","def normalize_features(block, norm=1):\n for k in block:\n for b in block[k]:\n nrm = np.sqrt((block[k][b].reshape((block[k][b].shape[0],-1))**2).sum(axis=1).mean(axis=0))\n if nrm > 0.0:\n block[k][b] *= norm/nrm","def normalize(data):\n row = np.size(data, 0) # number of data points\n col = np.size(data, 1) # dimensionality of data points\n for j in range(col):\n # find the average for each column\n col_sum = 0\n for i in range(row):\n col_sum = col_sum + data[i][j]\n col_sum = col_sum / row\n # subtract the average from each value in the column\n for i in range(row):\n data[i][j] = data[i][j] - col_sum\n return data","def normalize(data):\n row = np.size(data, 0) # number of data points\n col = np.size(data, 1) # dimensionality of data points\n for j in range(col):\n # find the average for each column\n col_sum = 0\n for i in range(row):\n col_sum = col_sum + data[i][j]\n col_sum = col_sum / row\n # subtract the average from each value in the column\n for i in range(row):\n data[i][j] = data[i][j] - col_sum\n return data","def normalize_ds(dataset):\n dataset = copy.copy(dataset)\n\n dim_dataset = dataset.shape\n\n for n_row in range(dim_dataset[0]):\n k = dataset[n_row,:]\n k_norm =(k - np.min(k))/(np.max(k) - np.min(k))\n dataset[n_row,:] = k_norm\n\n return dataset","def convert_norm(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n axis = op.attr(\"axis\")\n axis_l = [axis]\n epsilon = op.attr(\"epsilon\")\n out = _op.nn.l2_normalize(x, epsilon, axis_l)\n g.add_node(op.output(\"Out\")[0], out)","def normalize(self, mag=1.0):\n\n def f(dataset, s, null, mag):\n dataset[s] -= null\n dataset[s] /= mag\n\n if self.signed:\n mag = self.mag() / mag\n else:\n mag = self.max() / mag\n self.chunkwise(f, null=self.null, mag=mag)\n self._null = 0","def normalize(data):\n min = np.min(data)\n if min:\n data = data + min\n return old_div(data,np.max(data))\n else: # if min is 0\n return old_div(data,np.max(data))","def _center_data(X, y, fit_intercept, normalize=False, copy=True):\n X = as_float_array(X, copy)\n\n if fit_intercept:\n if sp.issparse(X):\n X_mean = np.zeros(X.shape[1])\n X_std = np.ones(X.shape[1])\n else:\n X_mean = X.mean(axis=0)\n X -= X_mean\n if normalize:\n X_std = np.sqrt(np.sum(X ** 2, axis=0))\n X_std[X_std == 0] = 1\n X /= X_std\n else:\n X_std = np.ones(X.shape[1])\n y_mean = y.mean()\n y = y - y_mean\n else:\n X_mean = np.zeros(X.shape[1])\n X_std = np.ones(X.shape[1])\n y_mean = 0.\n return X, y, X_mean, y_mean, X_std","def normalize(x):\n # TODO: Implement Function\n data_max = np.max(x)\n data_min = np.min(x)\n x = (x - data_min) / (data_max - data_min)\n return x","def _normalize(self, offset=0):\n if self.t.min() < offset:\n self.t += offset - abs(self.t.min())","def normalize_wrt_max(self):\n\n x_min = min(self.x)\n x_max = max(self.x)\n y_min = min(self.y)\n y_max = max(self.y)\n\n x_range = x_max - x_min\n y_range = y_max - y_min\n max_range = max(x_range, y_range)\n\n x = np.array(self.x)\n y = np.array(self.y)\n x -= x_min\n y -= y_min\n x = x / float(max_range)\n y = y / float(max_range)\n\n self.x = x.tolist()\n self.y = y.tolist()","def local_to_normalized(npboxes: np.ndarray, window: Box):\n height, width = window.size\n return npboxes / np.array([[height, width, height, width]])","def normalise(self):\n\n # Find extrema\n xmin = self.segments[0].lower_bound\n xmax = self.segments[0].upper_bound\n for seg in self.segments[1:]:\n xmin = min(xmin, seg.lower_bound)\n xmax = max(xmax, seg.upper_bound)\n\n range = xmax-xmin \n\n # Normalise\n for seg in self.segments:\n seg.lower_bound = (seg.lower_bound-xmin)/range\n seg.upper_bound = (seg.upper_bound-xmin)/range\n\n # Return\n return xmin, xmax","def normalise(image):","def normalize_data(x):\n mvec = x.mean(0)\n stdvec = x.std(axis=0)\n \n return (x - mvec)/stdvec","def normalize_data(x):\n mvec = x.mean(0)\n stdvec = x.std(axis=0)\n \n return (x - mvec)/stdvec","def _norm_data(data):\n if data is None:\n return data\n data_min = np.min(data)\n c_norm = np.max(data) - data_min\n return (data - data_min) / c_norm if (c_norm != 0) else (data - data_min)","def data_preprocessing(points):\n mean_coords = points.mean(0)\n points -= mean_coords\n \n max_norm = np.max(np.linalg.norm(points, axis = 1))\n points /= max_norm\n\n return points, mean_coords, max_norm","def normalize(self): # Function is fucked TODO\n l = self.length()\n for i in range(0, len(self.coords)):\n self.coords[i] /= l\n return self\n # return Vector(list([0 for i in range(len(v.coords))]))\n\n # if round(self.length() == 0):\n # s = 1 / self.length()\n # return self * s\n # else:\n # return Vector(list([0 for i in range(len(v.coords))]))","def normalize2(data):\n return old_div(data,np.max([np.max(data),-1.0*np.min(data)]))","def normalize(self,x,xmin,xmax):\n return (x-xmin)/(xmax-xmin)","def normalise(self):\n return self / self.mean(axis=1).reshape(self.shape[0], 1)","def batch_norm(in_tensor, phase_train, name, reuse=None, data_format='NHWC', center=True, scale=True):\n axis = -1 if data_format == 'NHWC' else 1\n with tf.variable_scope(name):\n # return tf.contrib.layers.batch_norm(in_tensor, is_training=phase_train, scope=scope, reuse=reuse)\n return tf.layers.batch_normalization(in_tensor, axis=axis, center=center, scale=scale, training=phase_train,\n reuse=reuse, fused=True, momentum=0.99, epsilon=1e-1)","def norm_data(self):\n if (self.nrows, self.ncolumns) < self.data.shape:\n self.data = self.data[0:self.nrows, 0:self.ncolumns]\n if self.data.dtype != np.float64:\n self.data = self.data.astype(np.float64)\n self.meanval = self.data.mean()\n self.stdval = self.data.std()","def normalized(self):\n d = self.magnitude()\n if d:\n return type(self)(self.x / d, self.y / d)\n return self.copy()","def normalize(img):\n # TODO: implement this function.\n min_img = min([min(i) for i in img])\n max_img = max([max(i) for i in img])\n\n for i in range(len(img)):\n \tfor j in range(len(img[0])):\n \t\timg[i][j] = ((img[i][j] - min_img) / (max_img - min_img))\n #raise NotImplementedError\n return img","def normalize(self):\n self.desc += \", normalize\"\n self._vecs /= np.linalg.norm(self._vecs, axis=1)[:, np.newaxis]\n self.reindex()","def _normalize(self):\r\n self.dataframe['norm_intensity'] = self.dataframe['intensity']\r\n self.dataframe['norm_intensity'] -= self.dataframe['norm_intensity'].min()\r\n self.dataframe['norm_intensity'] /= self.dataframe['norm_intensity'].max() * 0.01","def normalise(dataset):\n # Scale images to the [0, 1] range\n dataset = dataset.astype(\"float32\") / 255\n # Make sure images have shape (28, 28, 1)\n return np.expand_dims(dataset, -1)","def normalize(self):\n self.number_of_vectors = self.values.shape[0]\n norm_2 = np.linalg.norm(self.values, axis=1)\n norm_1 = np.sum(self.values_planar, axis=1)\n norm_2 = np.repeat(norm_2, self.number_of_objectives).reshape(\n self.number_of_vectors, self.number_of_objectives\n )\n norm_1 = np.repeat(norm_1, self.number_of_objectives).reshape(\n self.number_of_vectors, self.number_of_objectives\n )\n norm_2[norm_2 == 0] = np.finfo(float).eps\n self.values = np.divide(self.values, norm_2)\n self.values_planar = np.divide(self.values_planar, norm_1)","def normalize(grid, new_min, new_max, mask):\n\n norm_grid = (new_max - new_min) * \\\n (grid - grid[mask].min()) / (grid[mask].max() - \\\n grid[mask].min()) + new_min\n\n return norm_grid","def xy_norm(self):\n center_xy = self.to_xyah()[0:2]\n center_xy[0] = center_xy[0] / self.im_shape[1]\n center_xy[1] = center_xy[1] / self.im_shape[0]\n\n #assert 0 <= center_xy[0] <= 1 and 0 <= center_xy[1] <= 1\n return center_xy","def normalizeRows(x):\n\n ### YOUR CODE HERE\n # using l2 norm to normalize\n x = x / np.sqrt(np.sum(x * x, axis=-1, keepdims=True))\n ### END YOUR CODE\n\n return x","def normalizeRows(x):\n\n ### YOUR CODE HERE\n norm2 = np.linalg.norm(x,2,axis = 1).reshape(x.shape[0],-1)\n x = x/norm2\n ### END YOUR CODE\n\n return x","def normalized(self):\n len = self.length\n return Vector(self.x / len, self.y / len)","def normalize(self):\r\n\r\n nlen = 1.0/math.sqrt(self*self)\r\n return vec4(self.x*nlen, self.y*nlen, self.z*nlen, self.w*nlen)","def _localNormalizeData(self,values,names,feat):\n self.muAndSigmaFeatures[feat] = (0.0,1.0)","def normalize_data(data):\n mean = np.mean(data)\n std = np.std(data)\n return (data - mean) / std","def normalize_data(self, data):\n self.find_mean_std(data)\n return (data - self._data_mean) / self._data_std","def normalize(data):\n # normalize data and return\n # https://stackoverflow.com/questions/29661574/normalize-numpy-array-columns-in-python\n return (data - data.min(axis=0)) / data.ptp(axis=0)","def rescale_data(self):\n\n # Dividing every array of simulated data vectors by the mean of that array.\n '''# Didnt work\n for key in self.data.keys():\n self.data[key] /= np.mean(self.data[key])\n '''\n\n self.rescaled = True\n\n # Mean normalization\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.mean(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Median normalization\n \"\"\" didnt work, still dividing by large number \n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\n \"\"\"\n\n # Divide by median\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] -= np.median(self.data[key])\n self.data[key] /= (np.median(self.data[key]))\n \"\"\"\n\n # Take logarithm of data\n \"\"\" didnt work\n for key in self.data.keys():\n self.data[key] = np.log10(self.data[key])\n \"\"\"\n\n # Scale by length of vector\n \"\"\"\n for key in self.data.keys():\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\n \"\"\"\n\n \n # Scale by negative of the natural logarithm \n for key in self.data.keys():\n self.data[key] = -1 * np.log(self.data[key]) \n \n \"\"\"\n # Scale by subtracting the mean and dividing by std\n std = np.nanstd(self.data['data'])\n mean = np.nanmean(self.data['data'])\n for key in self.data.keys():\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\n self.data[key] -= mean \n self.data[key] /= std\n \"\"\"","def normalize(self):\n det = self._mat[0][0]*self._mat[1][1] - self._mat[0][1]*self._mat[1][0]\n for i in range(2):\n for j in range(2):\n self._mat[i][j] = (self._mat[i][j])/(np.sqrt(det))","def _centered_coords(self):\n\n array = self.detection_base.height_model.array\n height, width = self.detection_base.height_model.cell_size_x * array.shape[0], \\\n self.detection_base.height_model.cell_size_y * array.shape[1]\n min_x, min_y = self.detection_base.height_model._bounding_box[0], \\\n self.detection_base.height_model._bounding_box[2]\n\n coords = self.detection_base._coords_array_single\n coords[:, 0], coords[:,1] = coords[:, 0] - (min_x + (width / 2)), coords[:,1] - (min_y + (height / 2))\n return coords","def center(self, x):\n\n shape = x.shape\n nx = shape[1]\n ny = shape[0]\n hnx = nx // 2\n hny = ny // 2\n\n temp = x[0:hny, 0:hnx].copy()\n x[0:hny, 0:hnx] = x[hny:ny, hnx:nx].copy()\n x[hny:ny, hnx:nx] = temp\n\n temp = x[0:hny, hnx:nx].copy()\n x[0:hny, hnx:nx] = x[hny:ny, 0:hnx].copy()\n x[hny:ny, 0:hnx] = temp","def _normalize_point(self, p):\n segment_right_index = 1\n while p.x > self._hull_points[segment_right_index].x and segment_right_index < len(self._hull_points) - 1:\n segment_right_index += 1\n p1, p2 = self._hull_points[segment_right_index - 1], self._hull_points[segment_right_index]\n k = (p2.y - p1.y) / (p2.x - p1.x)\n b = p1.y - k * p1.x\n return Point(p.x, p.y / (k * p.x + b))","def normalize(self):\n if self.norm():\n self._ar = self._ar / self.norm()","def renorm(self):\n self.data -= self.data.min()\n self.data /= self.data.max()\n return self","def batch_norm(inputs, training, data_format):\n # We set fused=True for a significant performance boost. See\n # https://www.tensorflow.org/performance/performance_guide#common_fused_ops\n return tf.compat.v1.layers.batch_normalization(\n inputs=inputs, axis=1 if data_format == 'channels_first' else 3,\n momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True,\n scale=True, training=training, fused=True)","def normalize_data(X, range_d = None):\n n,d = X.shape\n\n if range_d is None:\n range_d = np.zeros([2,d])\n range_d[0,:] = np.min(X, axis = 0)\n range_d[1,:] = np.max(X, axis = 0)\n\n X = (X - range_d[0,:]) / (range_d[1,:] - range_d[0,:])\n\n return X","def normalize_coords(xx, yy, width, height):\n xx = (2.0 / (width - 1.0)) * xx.float() - 1.0\n yy = (2.0 / (height - 1.0)) * yy.float() - 1.0\n return xx, yy","def normalize_totensor(self, image):\n x = self.loader2(image)\n x = x.repeat(1, 1, 1, 1)\n if is_cuda: x = x.cuda()\n return x","def _compute_normalization(self, normalize=True):\n if normalize:\n if self._img_norm is None:\n if np.sum(self._data) == 0:\n self._img_norm = 1\n else:\n self._img_norm = self._compute_raw_image_norm()\n\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\n self._data /= (self._img_norm * self._normalization_correction)\n self._normalization_status = 0\n else:\n self._normalization_status = 1\n self._img_norm = 1\n warnings.warn('Overflow encountered while computing '\n 'normalization constant. Normalization '\n 'constant will be set to 1.', NonNormalizable)\n else:\n self._normalization_status = 2","def normalize_image(self):\n # The image normalization is identical to Cloud TPU ResNet.\n self._image = tf.image.convert_image_dtype(self._image, dtype=tf.float32)\n offset = tf.constant(DATASET_MEAN)\n offset = tf.expand_dims(offset, axis=0)\n offset = tf.expand_dims(offset, axis=0)\n self._image -= offset\n\n scale = tf.constant(DATASET_VAR)\n scale = tf.expand_dims(scale, axis=0)\n scale = tf.expand_dims(scale, axis=0)\n self._image /= scale","def normalized_to_local(npboxes: np.ndarray, window: Box):\n height, width = window.size\n return npboxes * np.array([[height, width, height, width]])","def normalize_data(data):\n if data.element_spec[0].shape[2] == 1:\n data = data.map(lambda x, y: (tf.image.grayscale_to_rgb(\n tf.image.resize(x, [32, 32])), y))\n else:\n data = data.map(lambda x, y: (tf.image.resize(x, [32, 32]), y))\n normalization_layer = tf.keras.layers.experimental.preprocessing.Rescaling(1. / 255)\n normalized_ds = data.map(lambda x, y: (normalization_layer(x), y))\n return normalized_ds","def euclidian_normalization(row):\n return row / np.sqrt(row.power(2).sum())","def normalize(self, X):\n return X - X.mean()","def batch_norm(inputs, training, data_format):\n # We set fused=True for a significant performance boost. See\n # https://www.tensorflow.org/performance/performance_guide#common_fused_ops\n return tf.layers.batch_normalization(\n inputs=inputs, axis=1 if data_format == 'channels_first' else 3,\n momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True,\n scale=True, training=training, fused=True)","def normalize(self):\n return Vector(self.args + []) / self.magnitude()","def normalized(self):\n d = self.magnitude()\n if d:\n return type(self)(self.x / d, self.y / d, self.z / d)\n return self.copy()","def normalize_wrt_y(self):\n\n x_min = min(self.x)\n y_min = min(self.y)\n y_max = max(self.y)\n\n y_range = y_max - y_min\n\n x = np.array(self.x)\n y = np.array(self.y)\n x -= x_min\n y -= y_min\n x = x / float(y_range)\n y = y / float(y_range)\n\n self.x = x.tolist()\n self.y = y.tolist()","def _normalize(array):\n\treturn (array - np.min(array))/(np.max(array)-np.min(array))","def normalization_brain(img, mask):\n zone1 = img[mask != 0]\n imge = img.copy()\n imge[mask != 0] = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\n imge[mask == 0] = 0\n return imge","def normalise(self):\n fitness_sum = np.sum(self.fitness)\n for i in range(self.loops):\n self.normalised_fitness[i] = self.fitness[i] / fitness_sum","def normalized_data(self):\n return self._normalization_constant * self._data","def normalize(self, x, train=True):\n if train is not None:\n mean, variance = tf.nn.moments(x, [0,1,2])\n assign_mean = self.mean.assign(mean)\n assign_variance = self.variance.assign(variance)\n with tf.control_dependencies([assign_mean, assign_variance]):\n return tf.nn.batch_norm_with_global_normalization(\n x, mean, variance, self.beta, self.gamma,\n self.epsilon, self.scale_after_norm)\n else:\n mean = self.ewma_trainer.average(self.mean)\n variance = self.ewma_trainer.average(self.variance)\n local_beta = tf.identity(self.beta)\n local_gamma = tf.identity(self.gamma)\n return tf.nn.batch_norm_with_global_normalization(\n x, mean, variance, local_beta, local_gamma,\n self.epsilon, self.scale_after_norm)","def normalize_face_landmarks(face_landmarks):\r\n\tface_landmarks_norm = np.zeros(face_landmarks.shape)\r\n\t\r\n\tfor (i, lm) in enumerate(face_landmarks):\r\n\t\tface_landmarks_norm[i] = lm - lm[nose_center_idx]\r\n\t\t\t\r\n\tstd_x = np.std(face_landmarks_norm[:,:,0].reshape((-1,)))\r\n\tstd_y = np.std(face_landmarks_norm[:,:,1].reshape((-1,)))\r\n\t\r\n\tface_landmarks_norm[:,:,0] = np.multiply(face_landmarks_norm[:,:,0], 1./std_x)\r\n\tface_landmarks_norm[:,:,1] = np.multiply(face_landmarks_norm[:,:,1], 1./std_y)\r\n\t\r\n\treturn face_landmarks_norm","def locations_normal(width, height, location):\n locations = location.copy()\n width *= 1.0\n height *= 1.0\n locations[0] = width*abs(locations[0])\n locations[1] = height*abs(locations[1])\n locations[2] = width*abs(locations[2])\n locations[3] = height*abs(locations[3])\n return locations","def normalize(self, df):\n return (df - df.mean()) / (df.max() - df.min())","def normalize(coords, radius):\n co = coords.copy()\n # calculate current distance\n dist = (coords[0] ** 2 + coords[1] ** 2 + coords[2] ** 2) ** 0.5\n # normalize\n for axis in range(3):\n co[axis] = coords[axis] / dist * radius\n return co","def normalize(array, inplace=False):\n if inplace:\n array -= ds_mean\n array /= ds_std\n else:\n array = (array - ds_mean) / ds_std\n return array","def _process(self, data: np.ndarray) -> np.ndarray:\n return data[..., 0] * self.scale","def update_transform(self):\n\n self.a = self.scale * self.pixel_size * math.cos(self.angle)\n self.d = self.scale * self.pixel_size * math.sin(self.angle)\n self.b = self.d\n self.e = -self.a\n self.c = self.point.x() - self.a*self.width/2.0 - self.b*self.height/2.0\n self.f = self.point.y() - self.d*self.width/2.0 - self.e*self.height/2.0\n\n self.bounding_box = [[self.c,self.f],[self.c+self.a*self.width,self.f+self.d*self.width],[self.c+self.a*self.width+self.b*self.height,self.f+self.d*self.width+self.e*self.height],[self.c+self.b*self.height,self.f+self.e*self.height],]","def normalize(data):\n data = numpy.asmatrix(data)\n std_devs = numpy.std(data, axis=1)\n std_devs[std_devs == 0] = 1 # prevent div by 0\n return (data - numpy.mean(data, axis=1)) / std_devs"],"string":"[\n \"def _normalize(self, dataset):\\n if self.max is None: # if we are normalizing the training set\\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\\n for row in dataset.index: # for each row in dataset\\n for col in self.features: # for each feature in the instance (exclude target)\\n dataset.at[row, col] = (dataset.at[row, col] - self.min[col]) / (self.max[col] - self.min[col]) if col != \\\"Bias\\\" else 1\",\n \"def normalize_data(data=None):\\n # Data pre-processing\\n n = data.shape[0]\\n for i in range(n):\\n xx = data[i,:,:]\\n xx -= np.mean(xx) # Centering in 0\\n xx /= np.linalg.norm(xx) # Normalizing to 1\\n data[i] = xx # Affect value\\n return data\",\n \"def normalize(self):\\n self._data /= self.norm()\",\n \"def normalise(self):\\n for at in self.atoms:\\n if at.x < 0. :\\n at.x = self.coordx + at.x\\n if at.y < 0. :\\n at.y = self.coordy + at.y\\n if at.z < 0. :\\n at.z = self.coordz + at.z\",\n \"def norm(self):\\r\\n old_origin = np.array(self.origin)\\r\\n self.origin = [0, 0, 0]\\r\\n old_origin[0] = old_origin[0] / self.x[0]\\r\\n old_origin[1] = old_origin[1] / self.y[1]\\r\\n old_origin[2] = old_origin[2] / self.z[2]\\r\\n self.data = ndimage.shift(self.data, -old_origin, mode='wrap')\",\n \"def normalize(batch_img: np.ndarray) -> np.ndarray:\\n batch_img = batch_img.astype('float32')\\n return batch_img / 127.5 - 1\",\n \"def normalize(self):\\n d = learning_utils.convert_data_to_2d(self._data)\\n d = learning_utils.normalize_2d(d)\\n self._data = learning_utils.convert_data_to_1d(d)\",\n \"def set_normalization(self, dataloader):\\n mean = 0\\n square = 0\\n for (data_in, _) in dataloader:\\n mean += data_in.mean()\\n square += data_in.pow(2).mean()\\n\\n mean /= len(dataloader)\\n square /= len(dataloader)\\n std = np.sqrt(square - mean ** 2)\\n\\n # The input data should be roughly normally distributed after\\n # passing through net_fixed.\\n self.scale_in.bias.data.fill_(- mean / std)\\n self.scale_in.weight.data.fill_(1 / std)\",\n \"def BatchNormalize(S):\\n mu = np.mean(S, axis=0)\\n v = np.mean((S-mu)**2, axis=0)\\n S = (S - mu) / np.sqrt(v + epsilon)\\n return S\",\n \"def normalize_wrt_x(self):\\n\\n x_min = min(self.x)\\n x_max = max(self.x)\\n y_min = min(self.y)\\n\\n x_range = x_max - x_min\\n\\n x = np.array(self.x)\\n y = np.array(self.y)\\n x -= x_min\\n y -= y_min\\n x = x / float(x_range)\\n y = y / float(x_range)\\n\\n self.x = x.tolist()\\n self.y = y.tolist()\",\n \"def normalize_batch(batch, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):\\n # normalize using imagenet mean and std\\n batch = batch.clone()\\n mean = torch.tensor(mean).view(-1, 1, 1)\\n std = torch.tensor(std).view(-1, 1, 1)\\n # if your image data is scaled to scale 0-255, uncomment the line below\\n # batch.div_(255.0)\\n return (batch - mean) / std\",\n \"def normalize_data(self):\\n\\t\\tfull_matrix = self.balance_clases()\\n\\t\\ttexture_matrix = Normalizer().fit_transform(X=full_matrix[:,range(0,24)])\\n\\n\\t\\treturn texture_matrix\",\n \"def normalize(dataset):\\n minVals = dataset.min(axis=0)\\n maxVals = dataset.max(axis=0)\\n factors = maxVals-minVals\\n num = dataset.shape[0]\\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \\n return norm_data\",\n \"def normalize_data(img):\\n nor = np.linalg.norm(img, axis = 1)\\n nor = np.reshape(nor, (len(img), 1))\\n img = np.divide(img, nor)\\n return img\",\n \"def normalize(self):\\r\\n max = np.amax(self.matrix)\\r\\n min = np.amin(self.matrix)\\r\\n\\r\\n self.matrix = ((self.matrix - min) / (max - min))\",\n \"def _normalize(self, x):\\n # TODO: imagenet normalization\\n\\n return x\",\n \"def normalize_dataset(self):\",\n \"def normalize(self):\\n total = 0.0\\n for i in range(0,self.npoints):\\n total+=self.y[i]*self._dx\\n for i in range(0,self.npoints):\\n self.y[i]/=total\\n return\",\n \"def normalize(shape):\\n s = shape\\n matrix = Shape.get_matrix(s.get_vector())\\n norm_x = math.sqrt(sum(matrix[:, 0] ** 2))\\n norm_y = math.sqrt(sum(matrix[:, 1] ** 2))\\n for pt in s.pts:\\n pt.x /= norm_x\\n pt.y /= norm_y\\n return s\",\n \"def center_normalize(x):\\n return (x - K.mean(x)) / K.std(x)\",\n \"def center_normalize(x):\\n return (x - K.mean(x)) / K.std(x)\",\n \"def _normalize_coordinates(\\n target_size: int, coords: np.ndarray, original_size: Tuple[int, int], is_bounding_box=False\\n) -> np.ndarray:\\n old_height, old_width = original_size\\n\\n scale = target_size * 1.0 / max(old_height, old_width)\\n new_height, new_width = old_height * scale, old_width * scale\\n new_width = int(new_width + 0.5)\\n new_height = int(new_height + 0.5)\\n\\n coords = deepcopy(coords).astype(float)\\n\\n if is_bounding_box:\\n coords = coords.reshape(-1, 2, 2)\\n\\n coords[..., 0] = coords[..., 0] * (new_width / old_width)\\n coords[..., 1] = coords[..., 1] * (new_height / old_height)\\n\\n if is_bounding_box:\\n coords = coords.reshape(-1, 4)\\n\\n return coords\",\n \"def normalize(self) -> \\\"CharacterizationPixel\\\":\\n return replace(\\n self,\\n data=self.data/self.norm,\\n mean=self.mean/self.norm,\\n norm=np.ones_like(self.norm),\\n )\",\n \"def normalize_data(self):\\n self.x_mean, self.x_std = du.get_mean_std(self.x_train)\\n self.x_train = du.normalize(self.x_train, self.x_mean, self.x_std)\\n if self.x_test is not None and self.y_test is not None:\\n self.x_test = du.normalize(self.x_test, self.x_mean, self.x_std)\\n self.normalized_data = True\",\n \"def convert_batch_norm(g, op, block):\\n\\n ipt_name = op.input(\\\"X\\\")[0]\\n scale_name = op.input(\\\"Scale\\\")[0]\\n bias_name = op.input(\\\"Bias\\\")[0]\\n mean_name = op.input(\\\"Mean\\\")[0]\\n variance_name = op.input(\\\"Variance\\\")[0]\\n epsilon = op.attr(\\\"epsilon\\\")\\n out = _op.nn.batch_norm(\\n g.get_node(ipt_name),\\n g.get_node(scale_name),\\n g.get_node(bias_name),\\n g.get_node(mean_name),\\n g.get_node(variance_name),\\n epsilon=epsilon,\\n )\\n g.add_node(op.output(\\\"Y\\\")[0], out[0])\",\n \"def centerMeanAndNormalize(df):\\n return minMax(df - df.mean(axis=0))\",\n \"def normalize_features(block, norm=1):\\n for k in block:\\n for b in block[k]:\\n nrm = np.sqrt((block[k][b].reshape((block[k][b].shape[0],-1))**2).sum(axis=1).mean(axis=0))\\n if nrm > 0.0:\\n block[k][b] *= norm/nrm\",\n \"def normalize(data):\\n row = np.size(data, 0) # number of data points\\n col = np.size(data, 1) # dimensionality of data points\\n for j in range(col):\\n # find the average for each column\\n col_sum = 0\\n for i in range(row):\\n col_sum = col_sum + data[i][j]\\n col_sum = col_sum / row\\n # subtract the average from each value in the column\\n for i in range(row):\\n data[i][j] = data[i][j] - col_sum\\n return data\",\n \"def normalize(data):\\n row = np.size(data, 0) # number of data points\\n col = np.size(data, 1) # dimensionality of data points\\n for j in range(col):\\n # find the average for each column\\n col_sum = 0\\n for i in range(row):\\n col_sum = col_sum + data[i][j]\\n col_sum = col_sum / row\\n # subtract the average from each value in the column\\n for i in range(row):\\n data[i][j] = data[i][j] - col_sum\\n return data\",\n \"def normalize_ds(dataset):\\n dataset = copy.copy(dataset)\\n\\n dim_dataset = dataset.shape\\n\\n for n_row in range(dim_dataset[0]):\\n k = dataset[n_row,:]\\n k_norm =(k - np.min(k))/(np.max(k) - np.min(k))\\n dataset[n_row,:] = k_norm\\n\\n return dataset\",\n \"def convert_norm(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n axis = op.attr(\\\"axis\\\")\\n axis_l = [axis]\\n epsilon = op.attr(\\\"epsilon\\\")\\n out = _op.nn.l2_normalize(x, epsilon, axis_l)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def normalize(self, mag=1.0):\\n\\n def f(dataset, s, null, mag):\\n dataset[s] -= null\\n dataset[s] /= mag\\n\\n if self.signed:\\n mag = self.mag() / mag\\n else:\\n mag = self.max() / mag\\n self.chunkwise(f, null=self.null, mag=mag)\\n self._null = 0\",\n \"def normalize(data):\\n min = np.min(data)\\n if min:\\n data = data + min\\n return old_div(data,np.max(data))\\n else: # if min is 0\\n return old_div(data,np.max(data))\",\n \"def _center_data(X, y, fit_intercept, normalize=False, copy=True):\\n X = as_float_array(X, copy)\\n\\n if fit_intercept:\\n if sp.issparse(X):\\n X_mean = np.zeros(X.shape[1])\\n X_std = np.ones(X.shape[1])\\n else:\\n X_mean = X.mean(axis=0)\\n X -= X_mean\\n if normalize:\\n X_std = np.sqrt(np.sum(X ** 2, axis=0))\\n X_std[X_std == 0] = 1\\n X /= X_std\\n else:\\n X_std = np.ones(X.shape[1])\\n y_mean = y.mean()\\n y = y - y_mean\\n else:\\n X_mean = np.zeros(X.shape[1])\\n X_std = np.ones(X.shape[1])\\n y_mean = 0.\\n return X, y, X_mean, y_mean, X_std\",\n \"def normalize(x):\\n # TODO: Implement Function\\n data_max = np.max(x)\\n data_min = np.min(x)\\n x = (x - data_min) / (data_max - data_min)\\n return x\",\n \"def _normalize(self, offset=0):\\n if self.t.min() < offset:\\n self.t += offset - abs(self.t.min())\",\n \"def normalize_wrt_max(self):\\n\\n x_min = min(self.x)\\n x_max = max(self.x)\\n y_min = min(self.y)\\n y_max = max(self.y)\\n\\n x_range = x_max - x_min\\n y_range = y_max - y_min\\n max_range = max(x_range, y_range)\\n\\n x = np.array(self.x)\\n y = np.array(self.y)\\n x -= x_min\\n y -= y_min\\n x = x / float(max_range)\\n y = y / float(max_range)\\n\\n self.x = x.tolist()\\n self.y = y.tolist()\",\n \"def local_to_normalized(npboxes: np.ndarray, window: Box):\\n height, width = window.size\\n return npboxes / np.array([[height, width, height, width]])\",\n \"def normalise(self):\\n\\n # Find extrema\\n xmin = self.segments[0].lower_bound\\n xmax = self.segments[0].upper_bound\\n for seg in self.segments[1:]:\\n xmin = min(xmin, seg.lower_bound)\\n xmax = max(xmax, seg.upper_bound)\\n\\n range = xmax-xmin \\n\\n # Normalise\\n for seg in self.segments:\\n seg.lower_bound = (seg.lower_bound-xmin)/range\\n seg.upper_bound = (seg.upper_bound-xmin)/range\\n\\n # Return\\n return xmin, xmax\",\n \"def normalise(image):\",\n \"def normalize_data(x):\\n mvec = x.mean(0)\\n stdvec = x.std(axis=0)\\n \\n return (x - mvec)/stdvec\",\n \"def normalize_data(x):\\n mvec = x.mean(0)\\n stdvec = x.std(axis=0)\\n \\n return (x - mvec)/stdvec\",\n \"def _norm_data(data):\\n if data is None:\\n return data\\n data_min = np.min(data)\\n c_norm = np.max(data) - data_min\\n return (data - data_min) / c_norm if (c_norm != 0) else (data - data_min)\",\n \"def data_preprocessing(points):\\n mean_coords = points.mean(0)\\n points -= mean_coords\\n \\n max_norm = np.max(np.linalg.norm(points, axis = 1))\\n points /= max_norm\\n\\n return points, mean_coords, max_norm\",\n \"def normalize(self): # Function is fucked TODO\\n l = self.length()\\n for i in range(0, len(self.coords)):\\n self.coords[i] /= l\\n return self\\n # return Vector(list([0 for i in range(len(v.coords))]))\\n\\n # if round(self.length() == 0):\\n # s = 1 / self.length()\\n # return self * s\\n # else:\\n # return Vector(list([0 for i in range(len(v.coords))]))\",\n \"def normalize2(data):\\n return old_div(data,np.max([np.max(data),-1.0*np.min(data)]))\",\n \"def normalize(self,x,xmin,xmax):\\n return (x-xmin)/(xmax-xmin)\",\n \"def normalise(self):\\n return self / self.mean(axis=1).reshape(self.shape[0], 1)\",\n \"def batch_norm(in_tensor, phase_train, name, reuse=None, data_format='NHWC', center=True, scale=True):\\n axis = -1 if data_format == 'NHWC' else 1\\n with tf.variable_scope(name):\\n # return tf.contrib.layers.batch_norm(in_tensor, is_training=phase_train, scope=scope, reuse=reuse)\\n return tf.layers.batch_normalization(in_tensor, axis=axis, center=center, scale=scale, training=phase_train,\\n reuse=reuse, fused=True, momentum=0.99, epsilon=1e-1)\",\n \"def norm_data(self):\\n if (self.nrows, self.ncolumns) < self.data.shape:\\n self.data = self.data[0:self.nrows, 0:self.ncolumns]\\n if self.data.dtype != np.float64:\\n self.data = self.data.astype(np.float64)\\n self.meanval = self.data.mean()\\n self.stdval = self.data.std()\",\n \"def normalized(self):\\n d = self.magnitude()\\n if d:\\n return type(self)(self.x / d, self.y / d)\\n return self.copy()\",\n \"def normalize(img):\\n # TODO: implement this function.\\n min_img = min([min(i) for i in img])\\n max_img = max([max(i) for i in img])\\n\\n for i in range(len(img)):\\n \\tfor j in range(len(img[0])):\\n \\t\\timg[i][j] = ((img[i][j] - min_img) / (max_img - min_img))\\n #raise NotImplementedError\\n return img\",\n \"def normalize(self):\\n self.desc += \\\", normalize\\\"\\n self._vecs /= np.linalg.norm(self._vecs, axis=1)[:, np.newaxis]\\n self.reindex()\",\n \"def _normalize(self):\\r\\n self.dataframe['norm_intensity'] = self.dataframe['intensity']\\r\\n self.dataframe['norm_intensity'] -= self.dataframe['norm_intensity'].min()\\r\\n self.dataframe['norm_intensity'] /= self.dataframe['norm_intensity'].max() * 0.01\",\n \"def normalise(dataset):\\n # Scale images to the [0, 1] range\\n dataset = dataset.astype(\\\"float32\\\") / 255\\n # Make sure images have shape (28, 28, 1)\\n return np.expand_dims(dataset, -1)\",\n \"def normalize(self):\\n self.number_of_vectors = self.values.shape[0]\\n norm_2 = np.linalg.norm(self.values, axis=1)\\n norm_1 = np.sum(self.values_planar, axis=1)\\n norm_2 = np.repeat(norm_2, self.number_of_objectives).reshape(\\n self.number_of_vectors, self.number_of_objectives\\n )\\n norm_1 = np.repeat(norm_1, self.number_of_objectives).reshape(\\n self.number_of_vectors, self.number_of_objectives\\n )\\n norm_2[norm_2 == 0] = np.finfo(float).eps\\n self.values = np.divide(self.values, norm_2)\\n self.values_planar = np.divide(self.values_planar, norm_1)\",\n \"def normalize(grid, new_min, new_max, mask):\\n\\n norm_grid = (new_max - new_min) * \\\\\\n (grid - grid[mask].min()) / (grid[mask].max() - \\\\\\n grid[mask].min()) + new_min\\n\\n return norm_grid\",\n \"def xy_norm(self):\\n center_xy = self.to_xyah()[0:2]\\n center_xy[0] = center_xy[0] / self.im_shape[1]\\n center_xy[1] = center_xy[1] / self.im_shape[0]\\n\\n #assert 0 <= center_xy[0] <= 1 and 0 <= center_xy[1] <= 1\\n return center_xy\",\n \"def normalizeRows(x):\\n\\n ### YOUR CODE HERE\\n # using l2 norm to normalize\\n x = x / np.sqrt(np.sum(x * x, axis=-1, keepdims=True))\\n ### END YOUR CODE\\n\\n return x\",\n \"def normalizeRows(x):\\n\\n ### YOUR CODE HERE\\n norm2 = np.linalg.norm(x,2,axis = 1).reshape(x.shape[0],-1)\\n x = x/norm2\\n ### END YOUR CODE\\n\\n return x\",\n \"def normalized(self):\\n len = self.length\\n return Vector(self.x / len, self.y / len)\",\n \"def normalize(self):\\r\\n\\r\\n nlen = 1.0/math.sqrt(self*self)\\r\\n return vec4(self.x*nlen, self.y*nlen, self.z*nlen, self.w*nlen)\",\n \"def _localNormalizeData(self,values,names,feat):\\n self.muAndSigmaFeatures[feat] = (0.0,1.0)\",\n \"def normalize_data(data):\\n mean = np.mean(data)\\n std = np.std(data)\\n return (data - mean) / std\",\n \"def normalize_data(self, data):\\n self.find_mean_std(data)\\n return (data - self._data_mean) / self._data_std\",\n \"def normalize(data):\\n # normalize data and return\\n # https://stackoverflow.com/questions/29661574/normalize-numpy-array-columns-in-python\\n return (data - data.min(axis=0)) / data.ptp(axis=0)\",\n \"def rescale_data(self):\\n\\n # Dividing every array of simulated data vectors by the mean of that array.\\n '''# Didnt work\\n for key in self.data.keys():\\n self.data[key] /= np.mean(self.data[key])\\n '''\\n\\n self.rescaled = True\\n\\n # Mean normalization\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.mean(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Median normalization\\n \\\"\\\"\\\" didnt work, still dividing by large number \\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.max(self.data[key]) - np.min(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Divide by median\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] -= np.median(self.data[key])\\n self.data[key] /= (np.median(self.data[key]))\\n \\\"\\\"\\\"\\n\\n # Take logarithm of data\\n \\\"\\\"\\\" didnt work\\n for key in self.data.keys():\\n self.data[key] = np.log10(self.data[key])\\n \\\"\\\"\\\"\\n\\n # Scale by length of vector\\n \\\"\\\"\\\"\\n for key in self.data.keys():\\n self.data[key] /= np.linalg.norm(self.Cl_noiseless)\\n \\\"\\\"\\\"\\n\\n \\n # Scale by negative of the natural logarithm \\n for key in self.data.keys():\\n self.data[key] = -1 * np.log(self.data[key]) \\n \\n \\\"\\\"\\\"\\n # Scale by subtracting the mean and dividing by std\\n std = np.nanstd(self.data['data'])\\n mean = np.nanmean(self.data['data'])\\n for key in self.data.keys():\\n # self.data[key] -= np.log(self.Cl_noiseless) # -1* # scale this same way\\n # self.data[key] -= self.Cl_noiseless # -1* # scale this same way\\n self.data[key] -= mean \\n self.data[key] /= std\\n \\\"\\\"\\\"\",\n \"def normalize(self):\\n det = self._mat[0][0]*self._mat[1][1] - self._mat[0][1]*self._mat[1][0]\\n for i in range(2):\\n for j in range(2):\\n self._mat[i][j] = (self._mat[i][j])/(np.sqrt(det))\",\n \"def _centered_coords(self):\\n\\n array = self.detection_base.height_model.array\\n height, width = self.detection_base.height_model.cell_size_x * array.shape[0], \\\\\\n self.detection_base.height_model.cell_size_y * array.shape[1]\\n min_x, min_y = self.detection_base.height_model._bounding_box[0], \\\\\\n self.detection_base.height_model._bounding_box[2]\\n\\n coords = self.detection_base._coords_array_single\\n coords[:, 0], coords[:,1] = coords[:, 0] - (min_x + (width / 2)), coords[:,1] - (min_y + (height / 2))\\n return coords\",\n \"def center(self, x):\\n\\n shape = x.shape\\n nx = shape[1]\\n ny = shape[0]\\n hnx = nx // 2\\n hny = ny // 2\\n\\n temp = x[0:hny, 0:hnx].copy()\\n x[0:hny, 0:hnx] = x[hny:ny, hnx:nx].copy()\\n x[hny:ny, hnx:nx] = temp\\n\\n temp = x[0:hny, hnx:nx].copy()\\n x[0:hny, hnx:nx] = x[hny:ny, 0:hnx].copy()\\n x[hny:ny, 0:hnx] = temp\",\n \"def _normalize_point(self, p):\\n segment_right_index = 1\\n while p.x > self._hull_points[segment_right_index].x and segment_right_index < len(self._hull_points) - 1:\\n segment_right_index += 1\\n p1, p2 = self._hull_points[segment_right_index - 1], self._hull_points[segment_right_index]\\n k = (p2.y - p1.y) / (p2.x - p1.x)\\n b = p1.y - k * p1.x\\n return Point(p.x, p.y / (k * p.x + b))\",\n \"def normalize(self):\\n if self.norm():\\n self._ar = self._ar / self.norm()\",\n \"def renorm(self):\\n self.data -= self.data.min()\\n self.data /= self.data.max()\\n return self\",\n \"def batch_norm(inputs, training, data_format):\\n # We set fused=True for a significant performance boost. See\\n # https://www.tensorflow.org/performance/performance_guide#common_fused_ops\\n return tf.compat.v1.layers.batch_normalization(\\n inputs=inputs, axis=1 if data_format == 'channels_first' else 3,\\n momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True,\\n scale=True, training=training, fused=True)\",\n \"def normalize_data(X, range_d = None):\\n n,d = X.shape\\n\\n if range_d is None:\\n range_d = np.zeros([2,d])\\n range_d[0,:] = np.min(X, axis = 0)\\n range_d[1,:] = np.max(X, axis = 0)\\n\\n X = (X - range_d[0,:]) / (range_d[1,:] - range_d[0,:])\\n\\n return X\",\n \"def normalize_coords(xx, yy, width, height):\\n xx = (2.0 / (width - 1.0)) * xx.float() - 1.0\\n yy = (2.0 / (height - 1.0)) * yy.float() - 1.0\\n return xx, yy\",\n \"def normalize_totensor(self, image):\\n x = self.loader2(image)\\n x = x.repeat(1, 1, 1, 1)\\n if is_cuda: x = x.cuda()\\n return x\",\n \"def _compute_normalization(self, normalize=True):\\n if normalize:\\n if self._img_norm is None:\\n if np.sum(self._data) == 0:\\n self._img_norm = 1\\n else:\\n self._img_norm = self._compute_raw_image_norm()\\n\\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\\n self._data /= (self._img_norm * self._normalization_correction)\\n self._normalization_status = 0\\n else:\\n self._normalization_status = 1\\n self._img_norm = 1\\n warnings.warn('Overflow encountered while computing '\\n 'normalization constant. Normalization '\\n 'constant will be set to 1.', NonNormalizable)\\n else:\\n self._normalization_status = 2\",\n \"def normalize_image(self):\\n # The image normalization is identical to Cloud TPU ResNet.\\n self._image = tf.image.convert_image_dtype(self._image, dtype=tf.float32)\\n offset = tf.constant(DATASET_MEAN)\\n offset = tf.expand_dims(offset, axis=0)\\n offset = tf.expand_dims(offset, axis=0)\\n self._image -= offset\\n\\n scale = tf.constant(DATASET_VAR)\\n scale = tf.expand_dims(scale, axis=0)\\n scale = tf.expand_dims(scale, axis=0)\\n self._image /= scale\",\n \"def normalized_to_local(npboxes: np.ndarray, window: Box):\\n height, width = window.size\\n return npboxes * np.array([[height, width, height, width]])\",\n \"def normalize_data(data):\\n if data.element_spec[0].shape[2] == 1:\\n data = data.map(lambda x, y: (tf.image.grayscale_to_rgb(\\n tf.image.resize(x, [32, 32])), y))\\n else:\\n data = data.map(lambda x, y: (tf.image.resize(x, [32, 32]), y))\\n normalization_layer = tf.keras.layers.experimental.preprocessing.Rescaling(1. / 255)\\n normalized_ds = data.map(lambda x, y: (normalization_layer(x), y))\\n return normalized_ds\",\n \"def euclidian_normalization(row):\\n return row / np.sqrt(row.power(2).sum())\",\n \"def normalize(self, X):\\n return X - X.mean()\",\n \"def batch_norm(inputs, training, data_format):\\n # We set fused=True for a significant performance boost. See\\n # https://www.tensorflow.org/performance/performance_guide#common_fused_ops\\n return tf.layers.batch_normalization(\\n inputs=inputs, axis=1 if data_format == 'channels_first' else 3,\\n momentum=_BATCH_NORM_DECAY, epsilon=_BATCH_NORM_EPSILON, center=True,\\n scale=True, training=training, fused=True)\",\n \"def normalize(self):\\n return Vector(self.args + []) / self.magnitude()\",\n \"def normalized(self):\\n d = self.magnitude()\\n if d:\\n return type(self)(self.x / d, self.y / d, self.z / d)\\n return self.copy()\",\n \"def normalize_wrt_y(self):\\n\\n x_min = min(self.x)\\n y_min = min(self.y)\\n y_max = max(self.y)\\n\\n y_range = y_max - y_min\\n\\n x = np.array(self.x)\\n y = np.array(self.y)\\n x -= x_min\\n y -= y_min\\n x = x / float(y_range)\\n y = y / float(y_range)\\n\\n self.x = x.tolist()\\n self.y = y.tolist()\",\n \"def _normalize(array):\\n\\treturn (array - np.min(array))/(np.max(array)-np.min(array))\",\n \"def normalization_brain(img, mask):\\n zone1 = img[mask != 0]\\n imge = img.copy()\\n imge[mask != 0] = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\\n imge[mask == 0] = 0\\n return imge\",\n \"def normalise(self):\\n fitness_sum = np.sum(self.fitness)\\n for i in range(self.loops):\\n self.normalised_fitness[i] = self.fitness[i] / fitness_sum\",\n \"def normalized_data(self):\\n return self._normalization_constant * self._data\",\n \"def normalize(self, x, train=True):\\n if train is not None:\\n mean, variance = tf.nn.moments(x, [0,1,2])\\n assign_mean = self.mean.assign(mean)\\n assign_variance = self.variance.assign(variance)\\n with tf.control_dependencies([assign_mean, assign_variance]):\\n return tf.nn.batch_norm_with_global_normalization(\\n x, mean, variance, self.beta, self.gamma,\\n self.epsilon, self.scale_after_norm)\\n else:\\n mean = self.ewma_trainer.average(self.mean)\\n variance = self.ewma_trainer.average(self.variance)\\n local_beta = tf.identity(self.beta)\\n local_gamma = tf.identity(self.gamma)\\n return tf.nn.batch_norm_with_global_normalization(\\n x, mean, variance, local_beta, local_gamma,\\n self.epsilon, self.scale_after_norm)\",\n \"def normalize_face_landmarks(face_landmarks):\\r\\n\\tface_landmarks_norm = np.zeros(face_landmarks.shape)\\r\\n\\t\\r\\n\\tfor (i, lm) in enumerate(face_landmarks):\\r\\n\\t\\tface_landmarks_norm[i] = lm - lm[nose_center_idx]\\r\\n\\t\\t\\t\\r\\n\\tstd_x = np.std(face_landmarks_norm[:,:,0].reshape((-1,)))\\r\\n\\tstd_y = np.std(face_landmarks_norm[:,:,1].reshape((-1,)))\\r\\n\\t\\r\\n\\tface_landmarks_norm[:,:,0] = np.multiply(face_landmarks_norm[:,:,0], 1./std_x)\\r\\n\\tface_landmarks_norm[:,:,1] = np.multiply(face_landmarks_norm[:,:,1], 1./std_y)\\r\\n\\t\\r\\n\\treturn face_landmarks_norm\",\n \"def locations_normal(width, height, location):\\n locations = location.copy()\\n width *= 1.0\\n height *= 1.0\\n locations[0] = width*abs(locations[0])\\n locations[1] = height*abs(locations[1])\\n locations[2] = width*abs(locations[2])\\n locations[3] = height*abs(locations[3])\\n return locations\",\n \"def normalize(self, df):\\n return (df - df.mean()) / (df.max() - df.min())\",\n \"def normalize(coords, radius):\\n co = coords.copy()\\n # calculate current distance\\n dist = (coords[0] ** 2 + coords[1] ** 2 + coords[2] ** 2) ** 0.5\\n # normalize\\n for axis in range(3):\\n co[axis] = coords[axis] / dist * radius\\n return co\",\n \"def normalize(array, inplace=False):\\n if inplace:\\n array -= ds_mean\\n array /= ds_std\\n else:\\n array = (array - ds_mean) / ds_std\\n return array\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n return data[..., 0] * self.scale\",\n \"def update_transform(self):\\n\\n self.a = self.scale * self.pixel_size * math.cos(self.angle)\\n self.d = self.scale * self.pixel_size * math.sin(self.angle)\\n self.b = self.d\\n self.e = -self.a\\n self.c = self.point.x() - self.a*self.width/2.0 - self.b*self.height/2.0\\n self.f = self.point.y() - self.d*self.width/2.0 - self.e*self.height/2.0\\n\\n self.bounding_box = [[self.c,self.f],[self.c+self.a*self.width,self.f+self.d*self.width],[self.c+self.a*self.width+self.b*self.height,self.f+self.d*self.width+self.e*self.height],[self.c+self.b*self.height,self.f+self.e*self.height],]\",\n \"def normalize(data):\\n data = numpy.asmatrix(data)\\n std_devs = numpy.std(data, axis=1)\\n std_devs[std_devs == 0] = 1 # prevent div by 0\\n return (data - numpy.mean(data, axis=1)) / std_devs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69384634","0.68707067","0.6639805","0.6637574","0.65870476","0.647955","0.644119","0.63818425","0.6363857","0.626459","0.62471074","0.62398934","0.62313163","0.6193541","0.6191717","0.61898583","0.618904","0.61679614","0.6146879","0.61388755","0.61388755","0.6099847","0.60972035","0.6087413","0.6067772","0.606484","0.6059595","0.60560733","0.60560733","0.6035024","0.59956515","0.59918237","0.5939435","0.59368247","0.5919703","0.59102976","0.5905241","0.5895396","0.58943075","0.5889778","0.58893615","0.58893615","0.58843887","0.5868397","0.5852394","0.58483803","0.5848179","0.5826572","0.58237267","0.5806352","0.5805472","0.5791806","0.57887983","0.5788131","0.578776","0.5772925","0.5769664","0.5768467","0.5765135","0.57633805","0.57541466","0.5750396","0.57492423","0.57386774","0.57354677","0.57292014","0.57284683","0.572418","0.57175684","0.57172614","0.5712119","0.57116145","0.5707921","0.57070726","0.5693983","0.56862533","0.5685538","0.5674443","0.5664632","0.5660147","0.5655295","0.5650882","0.5644384","0.564399","0.56334263","0.56306314","0.5627669","0.56162715","0.5614182","0.5610509","0.5603196","0.5599464","0.5599298","0.5598754","0.55896616","0.5582622","0.55819285","0.557933","0.5579109","0.55770206"],"string":"[\n \"0.69384634\",\n \"0.68707067\",\n \"0.6639805\",\n \"0.6637574\",\n \"0.65870476\",\n \"0.647955\",\n \"0.644119\",\n \"0.63818425\",\n \"0.6363857\",\n \"0.626459\",\n \"0.62471074\",\n \"0.62398934\",\n \"0.62313163\",\n \"0.6193541\",\n \"0.6191717\",\n \"0.61898583\",\n \"0.618904\",\n \"0.61679614\",\n \"0.6146879\",\n \"0.61388755\",\n \"0.61388755\",\n \"0.6099847\",\n \"0.60972035\",\n \"0.6087413\",\n \"0.6067772\",\n \"0.606484\",\n \"0.6059595\",\n \"0.60560733\",\n \"0.60560733\",\n \"0.6035024\",\n \"0.59956515\",\n \"0.59918237\",\n \"0.5939435\",\n \"0.59368247\",\n \"0.5919703\",\n \"0.59102976\",\n \"0.5905241\",\n \"0.5895396\",\n \"0.58943075\",\n \"0.5889778\",\n \"0.58893615\",\n \"0.58893615\",\n \"0.58843887\",\n \"0.5868397\",\n \"0.5852394\",\n \"0.58483803\",\n \"0.5848179\",\n \"0.5826572\",\n \"0.58237267\",\n \"0.5806352\",\n \"0.5805472\",\n \"0.5791806\",\n \"0.57887983\",\n \"0.5788131\",\n \"0.578776\",\n \"0.5772925\",\n \"0.5769664\",\n \"0.5768467\",\n \"0.5765135\",\n \"0.57633805\",\n \"0.57541466\",\n \"0.5750396\",\n \"0.57492423\",\n \"0.57386774\",\n \"0.57354677\",\n \"0.57292014\",\n \"0.57284683\",\n \"0.572418\",\n \"0.57175684\",\n \"0.57172614\",\n \"0.5712119\",\n \"0.57116145\",\n \"0.5707921\",\n \"0.57070726\",\n \"0.5693983\",\n \"0.56862533\",\n \"0.5685538\",\n \"0.5674443\",\n \"0.5664632\",\n \"0.5660147\",\n \"0.5655295\",\n \"0.5650882\",\n \"0.5644384\",\n \"0.564399\",\n \"0.56334263\",\n \"0.56306314\",\n \"0.5627669\",\n \"0.56162715\",\n \"0.5614182\",\n \"0.5610509\",\n \"0.5603196\",\n \"0.5599464\",\n \"0.5599298\",\n \"0.5598754\",\n \"0.55896616\",\n \"0.5582622\",\n \"0.55819285\",\n \"0.557933\",\n \"0.5579109\",\n \"0.55770206\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7281029"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9461,"cells":{"query":{"kind":"string","value":"Shuffle data and labels."},"document":{"kind":"string","value":"def shuffle_data(data, labels):\n idx = np.arange(len(labels))\n np.random.shuffle(idx)\n return data[idx, ...], labels[idx], idx"},"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 shuffle_data(self):\n images = list(self.train_images)\n labels = list(self.train_labels)\n self.train_images = []\n self.train_labels = []\n\n # create list of permutated index and shuffle data accoding to list\n idx = np.random.permutation(len(labels))\n for i in idx:\n self.train_images.append(images[i])\n self.train_labels.append(labels[i])","def shuffle_labels(self):\n random.shuffle(self.y_train)\n random.shuffle(self.y_test)","def shuffle_data(data, labels):\n idx = np.arange(len(labels))\n np.random.shuffle(idx)\n return data[idx], labels[idx]","def shuffle_data(data, labels):\n idx = np.arange(len(labels))\n np.random.shuffle(idx)\n return data[idx, ...], labels[idx], idx","def shuffle(self):\n self.x['train'], self.y['train'] = self._shuffle(\n self.x['train'],\n self.y['train']\n )","def shuffle_data(data, labels):\r\n idx = np.arange(len(labels))\r\n np.random.shuffle(idx)\r\n return data[idx, ...], labels[idx], idx","def shuffle_data(data, labels):\n idx = np.arange(len(labels))\n np.random.shuffle(idx)\n return data[idx, ...], labels[idx,...], idx","def shuffle_dataset(data, label, others=None, class_balanced=False):\n if class_balanced:\n sorted_ids = []\n\n for i in range(label.max() + 1):\n tmp_ids = np.where(label == i)[0]\n np.random.shuffle(tmp_ids)\n sorted_ids.append(tmp_ids)\n\n sorted_ids = np.stack(sorted_ids, 0)\n sorted_ids = np.transpose(sorted_ids, axes=[1, 0])\n ids = np.reshape(sorted_ids, (-1,))\n\n else:\n ids = np.arange(data.shape[0])\n np.random.shuffle(ids)\n\n if others is None:\n return data[ids], label[ids]\n else:\n return data[ids], label[ids], others[ids]","def inlabel_shuffle(data):\n num_zero_data = np.sum(data[:,-1]==0)\n label_zero_data = data[:num_zero_data,:]\n label_one_data = data[num_zero_data:,:]\n np.random.shuffle(label_zero_data)\n np.random.shuffle(label_one_data)\n return data","def shuffle_dataset(self, seed=None):\n stacked = np.r_[self.X_train,\n self.y_train]\n shuffle(stacked.T)\n X_shuffled = stacked[:self.nfeatures,:]\n y_shuffled = stacked[self.nfeatures:,:]\n return X_shuffled, y_shuffled","def shuffle(self):\n self.train_nodes = np.random.permutation(self.train_nodes)\n self.batch_num = 0","def shuffle(self):\n self.train_nodes = np.random.permutation(self.train_nodes)\n self.batch_num = 0","def shuffle(self):\n self.train_edges = np.random.permutation(self.train_edges)\n self.nodes = np.random.permutation(self.nodes)\n self.batch_num = 0","def shuffle_train(self):\r\n if self.data_container.task == 'Classify':\r\n id_train_list=[]\r\n for i in self.idx_train_list:\r\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\r\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\r\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\r\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\r\n \r\n self.idx['train'] = self._random_state.permutation(self.idx['train'])","def shuffle_dataset(instances, labels, seed):\n data = list(zip(instances, labels))\n\n if isinstance(seed, int):\n random.Random(seed).shuffle(data)\n else:\n random.Random().shuffle(data)\n\n instances, labels = zip(*data)\n\n return instances, labels","def shuffle_datasets(self):\n assert self.data_tags is not None\n assert self.training_dataset is not None\n assert self.validation_dataset is not None\n self.training_dataset = self.shuffle_data_dictionary(self.training_dataset)\n self.validation_dataset = self.shuffle_data_dictionary(self.validation_dataset)","def shuffle_T(self):\n np.random.shuffle(self.T)","def shuffle(self):\n perm = self.rng.permutation(self.inputs.shape[0])\n self._current_order = self._current_order[perm]\n self.inputs = self.inputs[perm]\n self.targets = self.targets[perm]\n self.target_ids = self.target_ids[perm]","def shuffle(self):\n perm = self.rng.permutation(self.inputs.shape[0])\n self._current_order = self._current_order[perm]\n self.inputs = self.inputs[perm]\n self.targets = self.targets[perm]","def _shuffle(self, reinit_indexes = False):\n print('Shuffling data...')\n # set seed for reproducibility\n #random.seed()\n # shuffle identities\n random.shuffle(self.identities)\n # shuffle images associated to each identity\n for identity in self.groundtruth_metadata.keys():\n random.shuffle(self.groundtruth_metadata[identity]['metadata'])\n if reinit_indexes:\n self.groundtruth_metadata[identity]['index'] = 0\n print('Finished shuffling data!')","def shuffleData(self, x, y):\n #get new random order for inputs and targets\n order = np.arange( x.shape[0] )\n random.shuffle( order )\n #reorder inputs and targets\n return x[order], y[order]","def shuffle(self):\n self.np_random.shuffle(self.deck)","def load_data_train(self, shuffle=True):\n\n data, label = self._generate_all_combinations_of_stripe_images(shuffle=shuffle);\n\n return data, label;","def shuffle(self, random_state=None): \n if random_state is None:\n random_state = self.random_state\n perm_ids = random_state.permutation(self.n_examples)\n self.u = self.u[perm_ids]\n self.v = self.v[perm_ids]\n self.rating = self.rating[perm_ids]","def shuffled_copies(samples, labels):\n\n # Check if the samples and labels are from the same format\n assert len(samples) == len(labels)\n permu = np.random.permutation(len(samples))\n\n # Get the correct indexes\n samples = samples[permu]\n labels = labels[permu]\n\n return samples, labels","def shuffle(self):\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\n perm = np.random.permutation(self.X_data.shape[0])\n for old_idx, new_idx in enumerate(perm):\n new_X[new_idx] = self.X_data[old_idx]\n new_Y[new_idx] = self.Y_data[old_idx]\n self.X_data = new_X\n self.Y_data = new_Y","def shuffle(self):\n order = np.arange(len(self.data))\n np.random.seed(0xA5EED)\n np.random.shuffle(order)\n self.data = self.data.iloc[order]\n return order","def shuffle(self):\n self.edges = np.random.permutation(self.edges)\n self.batch_num = 0","def shuffle(data):\n\n shuffle = np.arange(data.shape[0])\n np.random.shuffle(shuffle)\n undo_shuffle = np.argsort(shuffle)\n\n return (data[shuffle], undo_shuffle)","def shuffle_train_data(X_train, Y_train):\n perm = np.random.permutation(len(Y_train))\n Xtr_shuf = X_train[perm]\n Ytr_shuf = Y_train[perm]\n\n return Xtr_shuf, Ytr_shuf","def shuffle(self):\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\n if self.schema != 'default':\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\n\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, \\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\n self.neg_paths_shuffled, \\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths,\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\n self.neg_paths_sampled,\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\n self.pos_paths_words, self.neg_paths_words_sampled)\n else:\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)","def shuffle(self):\r\n random.shuffle(self.deck)","def shuffle(self):\n random.shuffle(self.get_cards())","def shuffle_question(self):\n r = random.SystemRandom()\n r.shuffle(self.question_list)","def shuffle_data(data):\n idx = np.arange(len(data))\n np.random.shuffle(idx)\n return data[idx, ...]","def shuffle_data(data):\n indices = list(range(data.shape[0]))\n np.random.shuffle(indices)\n return data[indices]","def shuffle(self):\n random.shuffle(self.deckcards)","def shuffle(self):\n shuffle(self.cards)","def shuffle(self):\n shuffle(self.cards)","def shuffle(self):\n\t\t\trandom.seed(231)\n\t\t\trandom.shuffle(self.Ind)\n\t\t\tself.Ind = self.Ind[:int(len(self.Ind)/5)*5].reshape((self.cv_iters, -1))\n\t\t\t#index of valication set\n\t\t\tself.CVindex = 1\n\t\t\tself.Testindex = 0","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.SystemRandom().shuffle(self.deck)","def shuffle(inputData):\n\n x = inputData[0]\n y = inputData[1]\n m = inputData[2]\n \n N = np.arange(0,x.shape[0])\n np.random.shuffle(N)\n \n x = x[N,:]\n y = y[N]\n m = m[N,:]\n \n return [x,y,m]","def shuffle_songs(self):\n random.shuffle(self.playlist)","def shuffle_dataset(self):\n # TODO explain approached used for selecting training and test data\n labels = self.dataset.label.unique()\n good_jobs = self.dataset[self.dataset.label == \"Good\"]\n bad_jobs = self.dataset[self.dataset.label == \"Bad\"]\n\n # TODO n>2 probablly won't work the way it's supposed to currently\n if len(labels) == 2:\n # oversample\n resize = max(len(good_jobs.label),len(bad_jobs.label))\n # undersample\n resize = min(len(good_jobs.label), len(bad_jobs.label))\n good_jobs_re = good_jobs.sample(resize)\n bad_jobs_re = bad_jobs.sample(resize)\n dataset = pd.concat([good_jobs_re, bad_jobs_re])\n elif len(labels) == 3:\n neutral_jobs = self.dataset[self.dataset.label == \"Neutral\"]\n # oversample\n resize = max(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\n # undersample\n resize = min(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\n\n good_jobs_re = good_jobs.sample(resize, replace=True)\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re])\n elif len(labels) == 4:\n neutral_jobs = self.dataset[self.dataset.label == \"Neutral\"]\n ideal_jobs = self.dataset[self.dataset.label == \"Ideal\"]\n\n # middle of the road approach\n resize = int(mean([len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label),len(ideal_jobs.label)]))\n good_jobs_re = good_jobs.sample(resize, replace=True)\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\n ideal_jobs_re = ideal_jobs.sample(resize,replace=True)\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re,ideal_jobs_re])\n\n train,test = train_test_split(dataset,test_size=0.25,stratify = dataset.label,shuffle=True)\n #test = self.dataset[~self.dataset.isin(train)].dropna()\n #test = self.dataset[(~dataset.label.isin(self.dataset.label))&(~dataset.description.isin(self.dataset.description))]\n #0tr_hashes = [hash(tuple(d)) for d in train.description]\n #ytest = [val for iter,val in self.dataset.iterrows() if hash(tuple(val.description)) not in tr_hashes]\n\n self.y_train,self.y_test = train.label.values,test.label.values\n self.X_train,self.X_test = train.description.values,test.description.values","def shuffle_data(y, data):\n combined = np.c_[data.reshape(len(data), -1), y.reshape(len(y), -1)]\n np.random.shuffle(combined)\n shuffled_data = combined[:, :data.size // len(data)].reshape(data.shape)\n shuffled_y = combined[:, data.size // len(data):].reshape(y.shape)\n return [shuffled_y, shuffled_data]","def shuffle(self):\n reorder(self.cards) #importing shuffle as reorder","def shuffle(self):\n self.shuffle_range(len(self.cards))","def shuffle(self):\n import random\n random.shuffle(self.cards)","def _shuffle():\n\n random.shuffle(deck)","def shuffle(self) -> None:\r\n random.shuffle(self._deck)","def shuffle(self):\n for i in range(10):\n random.shuffle(self.set)","def shuffle( self ):\n random.shuffle(self.__deck)","def shuffle(self, x_data, y_data, samples, x_fields, y_fields, swaps_g=None):\n if swaps_g is None:\n swaps_np = np.arange(samples, dtype=cltypes.uint)\n np.random.shuffle(swaps_np)\n swaps_g = array.to_device(self.queue, swaps_np, allocator=self.read_only_arr)\n # print(\"swaps:\", swaps_g.get())\n e1 = self.shuffle_krnl(self.queue, (x_fields, samples // 2), None, x_data, swaps_g.data)\n e2 = self.shuffle_krnl(self.queue, (y_fields, samples // 2), None, y_data, swaps_g.data)\n e1.wait()\n e2.wait()","def load_data_and_labels_without_shuffled():\n # Load data from files\n with codecs.open('./data/train_pos.txt', 'r+', 'utf-8') as f:\n train_pos = f.readlines()\n with codecs.open('./data/dev_pos.txt', 'r+', 'utf-8') as f:\n dev_pos = f.readlines()\n with codecs.open('./data/train_neg.txt', 'r+', 'utf-8') as f:\n train_neg = f.readlines()\n with codecs.open('./data/dev_neg.txt', 'r+', 'utf-8') as f:\n dev_neg = f.readlines()\n\n positive_examples1 = []\n positive_examples2 = []\n negative_examples1 = []\n negative_examples2 = []\n\n for i in train_pos:\n item1, item2 = i.split('\\t')\n item1 = remove_stop_word(item1)\n item2 = remove_stop_word(item2)\n positive_examples1.append(item1)\n positive_examples2.append(item2)\n\n for i in train_neg:\n item1, item2 = i.split('\\t')\n item1 = remove_stop_word(item1)\n item2 = remove_stop_word(item2)\n negative_examples1.append(item1)\n negative_examples2.append(item2)\n\n # Split by words\n x_text_train1 = positive_examples1 + negative_examples1\n x_text_train2 = positive_examples2 + negative_examples2\n\n positive_dev1 = []\n positive_dev2 = []\n negative_dev1 = []\n negative_dev2 = []\n\n for i in dev_pos:\n item1, item2 = i.split('\\t')\n item1 = remove_stop_word(item1)\n item2 = remove_stop_word(item2)\n positive_dev1.append(item1)\n positive_dev2.append(item2)\n\n for i in dev_neg:\n item1, item2 = i.split('\\t')\n item1 = remove_stop_word(item1)\n item2 = remove_stop_word(item2)\n negative_dev1.append(item1)\n negative_dev2.append(item2)\n\n x_text_dev1 = positive_dev1 + negative_dev1\n x_text_dev2 = positive_dev2 + negative_dev2\n\n # Generate labels\n train_positive_labels = [[0, 1] for _ in train_pos]\n dev_positive_labels = [[0, 1] for _ in dev_pos]\n train_negative_labels = [[1, 0] for _ in train_neg]\n dev_negative_labels = [[1, 0] for _ in dev_neg]\n y_train = np.concatenate([train_positive_labels, train_negative_labels], 0)\n y_dev = np.concatenate([dev_positive_labels, dev_negative_labels], 0)\n\n return [x_text_train1, x_text_train2, x_text_dev1, x_text_dev2, y_train, y_dev]","def shuffle(self) -> None:\n shuffle(self.cards)","def shuffle(self) -> NoReturn:\n for edge_type in self.edge_types:\n for edge_class in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][edge_class] = np.random.permutation(\n self.train_edges[edge_type][edge_class])\n\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\n for edge_type, edge_class in self.edge_types.items()}\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\n self.edge_types.items()}\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\n self.iter = 0","def shuffle_data(X, y, seed=None):\n if seed:\n np.random.seed(seed)\n idx = np.arange(X.shape[0])\n np.random.shuffle(idx)\n return X[idx], y[idx]","def shuffle_data(X, y, seed=None):\n if seed:\n np.random.seed(seed)\n idx = np.arange(X.shape[0])\n np.random.shuffle(idx)\n return X[idx], y[idx]","def shuffle_data(X, y, seed=None):\n if seed:\n np.random.seed(seed)\n idx = np.arange(X.shape[0])\n np.random.shuffle(idx)\n return X[idx], y[idx]","def prepare_imdb_data(data, labels, should_shuffle=True):\n\n #Combine positive and negative reviews and labels\n data_train = data['train']['pos'] + data['train']['neg']\n data_test = data['test']['pos'] + data['test']['neg']\n labels_train = labels['train']['pos'] + labels['train']['neg']\n labels_test = labels['test']['pos'] + labels['test']['neg']\n\n #Shuffle reviews and corresponding labels within training and test sets\n if should_shuffle:\n data_train, labels_train = shuffle(data_train, labels_train)\n data_test, labels_test = shuffle(data_test, labels_test)\n\n # Return a unified training data, test data, training labels, test labets\n return data_train, data_test, labels_train, labels_test","def random_preprocessing(inputs, labels):\r\n indices = range(0, labels.shape[0])\r\n shuffled_indices = tf.random.shuffle(indices)\r\n inputs = tf.gather(inputs, shuffled_indices)\r\n labels = tf.gather(labels, shuffled_indices)\r\n return inputs, labels","def shuffle_data(X, Y):\n m, nx = Y.shape\n shuffled = np.random.permutation(m)\n X_shuffled = X[shuffled]\n Y_shuffled = Y[shuffled]\n return X_shuffled, Y_shuffled","def shuffle(input_dataset, target_dataset):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\t\tassert(input_dataset.shape[0] == target_dataset.shape[0])\n\t\t\n\t\tperm = np.random.permutation(input_dataset.shape[0])\n\n\t\treturn input_dataset[perm], target_dataset[perm]\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def shuffle(self, random_seed: int = 0):\n # shuffle feature model clauses (used for div. promotion)\n random.seed(random_seed)\n clauses_ = []\n for clause in self.clauses_raw:\n clause_ = random.sample(clause, len(clause))\n clauses_.append(clause_)\n clauses = random.sample(clauses_, len(clauses_))\n \n self.clauses, self.target = FeatureModel.__convert_dimacs_to_bitvec(clauses, len(self.feature_dict))","def next_batch(num, data, labels):\n idx = np.arange(0 , len(data))\n np.random.shuffle(idx)\n idx = idx[:num]\n data_shuffle = [data[i] for i in idx]\n labels_shuffle = [labels[i] for i in idx]\n\n return np.asarray(data_shuffle), np.asarray(labels_shuffle)","def _shuffle(inputs):\n\texpand_inputs = tf.stack(inputs, axis = -1)\n\tshuffled_inputs = tf.random_shuffle(expand_inputs)\n\treturn tf.unstack(shuffled_inputs)","def data_loader(self, dataset=None, shuffle=True, size=None):\n self.log.info(\"Loading data\")\n assert dataset is not None, \"Please provide a dataset (folder name)\"\n data_path = os.path.join(config.DATA_DIR, dataset)\n # Load dataset using pickle\n with open(data_path, 'rb') as file:\n image_paths, labels = pickle.load(file)\n one_hot_labels = []\n images = []\n for i, (path, label) in enumerate(zip(image_paths, labels)):\n try:\n # One-hot encode the vectors\n one_hot = [0, 0, 0, 0]\n one_hot[label] = 1.0\n # Clean up image, normalize (mean to 0, std to 1)\n image = Image.open(path)\n image = np.asarray(image, dtype=np.float32) / 255\n except: # If there is some issue reading in data, skip datapoint\n continue\n one_hot_labels.append(np.asarray(one_hot, dtype=np.float32))\n images.append(image)\n # Shuffle data before cutting it into test and src\n if shuffle:\n x = list(zip(images, one_hot_labels))\n random.shuffle(x)\n images, one_hot_labels = zip(*x)\n self.log.info(\"Separating data into test and src.\")\n split_idx = int(config.TRAIN_TEST_SPLIT * len(one_hot_labels))\n train_input = images[:split_idx]\n train_target = one_hot_labels[:split_idx]\n test_input = images[split_idx:]\n test_target = one_hot_labels[split_idx:]\n if size:\n assert size < len(train_input), \"Final dataset size too big, not enough data\"\n train_input = train_input[:size]\n train_target = train_target[:size]\n self.log.info(\" -- test : {}\".format(len(test_target)))\n self.log.info(\" -- src: {}\".format(len(train_target)))\n # Convert to nparray before sending over\n return np.array(train_input), \\\n np.array(train_target), \\\n np.array(test_input), \\\n np.array(test_target)","def shuffle(self):\n for edge_type in self.edge_types:\n for k in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\n self.current_edge_type_idx = 0\n self.freebatch_edge_types = list(range(self.num_edge_types))\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\n self.iter = 0","def _shuffle(x, y):\n ind = np.arange(y.shape[0])\n np.random.shuffle(ind)\n\n return x[:, ind, :], y[ind]","def next_batch(num, data, labels):\n idx = np.arange(0, len(data))\n np.random.shuffle(idx)\n idx = idx[:num]\n data_shuffle = [data[i] for i in idx]\n labels_shuffle = [labels[i] for i in idx]\n \n return np.asarray(data_shuffle), np.asarray(labels_shuffle)","def __shuffle_cards(self):\n random.shuffle(self.cards)","def shuffle_and_split_data(X_genesets, y, train_size, validate_size):\n permutation = np.random.permutation(y.size)\n y_permuted = y[permutation]\n X_genesets_permuted = [Xg[permutation, :] for Xg in X_genesets]\n X_groups_train = [Xg[0:train_size, :] for Xg in X_genesets_permuted]\n X_groups_validate = [Xg[train_size: validate_size + train_size, :] for Xg in X_genesets_permuted]\n X_groups_test = [Xg[validate_size + train_size:, :] for Xg in X_genesets_permuted]\n y_train = y_permuted[0:train_size]\n y_validate = y_permuted[train_size: validate_size + train_size]\n y_test = y_permuted[validate_size + train_size:]\n return X_groups_train, y_train, X_groups_validate, y_validate, X_groups_test, y_test","def shuffle(self, inp: Tensor):\n _seed = self._seed() if callable(self._seed) else self._seed\n inp._reset(_shuffle(inp=inp, seed=_seed, handle=self._handle))","def randomize(data):\r\n permutation = np.random.permutation(data.shape[0])\r\n shuffled_data = data[permutation, :]\r\n # shuffled_y = y[permutation]\r\n return shuffled_data","def Shuffle(self):\r\n random.shuffle(self.cards_list)","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]","def _shuffle(self):\n print \"Shuffled the bag\"\n # The 'random' library provides a really handy function we can\n # use called 'shuffle'. You provide 'shuffle' with a\n # 'sequence' (basically, a list) and the shuffle function\n # randomizes the placement of all items in the sequence\n # automatically. There is no return value from\n # \"random.shuffle\" because \"self.bag\" is modified in place.\n random.shuffle(self.bag)","def shuffle(self):\n index = list(range(self.k))\n random.shuffle(index)\n for i, j in enumerate(index):\n self.list[i] = self.dic[j]\n return self.list","def shuffle(lol, seed):\n for l in lol:\n random.seed(seed)\n random.shuffle(l)","def main():\n input_1 = [7, 6, 5, 4, 3, 2, 1]\n print shuffle(input_1)\n print input_1","def shuffle_in_unison(self, x_train, y_train,split=0.1):\n n = np.size(x_train,axis=0)\n p = np.random.permutation(len(x_train))\n cutoff = int(split*n)\n p_val = p[0:cutoff]\n p_train = p[cutoff:]\n return x_train[p_train], y_train[p_train], x_train[p_val], y_train[p_val]","def _oversample(self, imgs_paths):\n # Split by label\n labels = [bool(self._get_img_label(path)) for path in imgs_paths]\n without_tomato = imgs_paths[np.invert(labels)]\n with_tomato = imgs_paths[labels]\n\n # Augment the dataset by transformation\n internal_transforms = [\n None,\n T.RandomHorizontalFlip(1),\n T.RandomVerticalFlip(1),\n RotationTransform(-90),\n RotationTransform(90)\n ]\n\n paths_transforms = [\n (path, transform)\n for path in with_tomato\n for transform in internal_transforms\n ] + [(path, None) for path in without_tomato]\n\n result = np.array(paths_transforms)\n np.random.shuffle(result)\n return result","def sample_models(self):\n label_sets = []\n free_labels = xrange(self.label_count)\n \n while len(label_sets) < self.model_count:\n label_set = random.sample(free_labels, self.labelset_size)\n if label_set not in label_sets:\n label_sets.append(label_set)\n\n self.label_sets = label_sets","def reset(self):\n self.epochs = 0\n # Shuffle the training data\n perm = np.arange(self.num_train)\n np.random.shuffle(perm)\n assert self.num_train == self.train_images.shape[\n 0], 'Error incorrect shuffling mask'\n self.train_images = self.train_images[perm]\n self.train_labels = self.train_labels[perm]\n self.curr_train_index = 0","def shuffle(data, shuffle_size=10000):\n buf = []\n for sample in data:\n buf.append(sample)\n if len(buf) >= shuffle_size:\n random.shuffle(buf)\n for x in buf:\n yield x\n buf = []\n # The sample left over\n random.shuffle(buf)\n for x in buf:\n yield x","def shuffle_mode(self, shuffle=True):\n self._shuffle = shuffle","def next_batch_shuffle(self, batch_size):\n\tperm0 = np.arange(self.TRAIN_SIZE)\n np.random.shuffle(perm0)\n self.data['x_train'], self.data['y_train'] = self.data['x_train'][perm0,:], self.data['y_train'][perm0,:]\n\treturn self.data['x_train'][:batch_size], self.data['y_train'][:batch_size]","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def _shuffle(self, r, idx_to_shuffle = None):\n n_features = r.shape[0]\n n_trials = r.shape[1]\n r_sh = r\n if idx_to_shuffle is None:\n idx_to_shuffle = range(n_features)\n for i in range(n_features):\n if i in idx_to_shuffle:\n r_sh[i,:] = r[i,random.permutation(range(n_trials))]\n return r_sh","def shuffle_data(X,y,z):\n data = np.row_stack((X, y, z))\n np.random.shuffle(data.T)\n X = data[:-2,:]\n y = data[-2,:]\n z = data[-1,:]\n\n return X, y, z","def batch_generator(batch_size, data, labels=None):\n n_batches = int(np.ceil(len(data) / float(batch_size)))\n idx = np.random.permutation(len(data))\n data_shuffled = data[idx]\n if labels is not None:\n labels_shuffled = labels[idx]\n for i in range(n_batches):\n start = i * batch_size\n end = start + batch_size\n if labels is not None:\n yield data_shuffled[start:end, :], labels_shuffled[start:end]\n else:\n yield data_shuffled[start:end, :]","def shuffle_aligned_list(data):\n num = data[0].shape[0]\n p = np.random.permutation(num)\n return [d[p] for d in data]"],"string":"[\n \"def shuffle_data(self):\\n images = list(self.train_images)\\n labels = list(self.train_labels)\\n self.train_images = []\\n self.train_labels = []\\n\\n # create list of permutated index and shuffle data accoding to list\\n idx = np.random.permutation(len(labels))\\n for i in idx:\\n self.train_images.append(images[i])\\n self.train_labels.append(labels[i])\",\n \"def shuffle_labels(self):\\n random.shuffle(self.y_train)\\n random.shuffle(self.y_test)\",\n \"def shuffle_data(data, labels):\\n idx = np.arange(len(labels))\\n np.random.shuffle(idx)\\n return data[idx], labels[idx]\",\n \"def shuffle_data(data, labels):\\n idx = np.arange(len(labels))\\n np.random.shuffle(idx)\\n return data[idx, ...], labels[idx], idx\",\n \"def shuffle(self):\\n self.x['train'], self.y['train'] = self._shuffle(\\n self.x['train'],\\n self.y['train']\\n )\",\n \"def shuffle_data(data, labels):\\r\\n idx = np.arange(len(labels))\\r\\n np.random.shuffle(idx)\\r\\n return data[idx, ...], labels[idx], idx\",\n \"def shuffle_data(data, labels):\\n idx = np.arange(len(labels))\\n np.random.shuffle(idx)\\n return data[idx, ...], labels[idx,...], idx\",\n \"def shuffle_dataset(data, label, others=None, class_balanced=False):\\n if class_balanced:\\n sorted_ids = []\\n\\n for i in range(label.max() + 1):\\n tmp_ids = np.where(label == i)[0]\\n np.random.shuffle(tmp_ids)\\n sorted_ids.append(tmp_ids)\\n\\n sorted_ids = np.stack(sorted_ids, 0)\\n sorted_ids = np.transpose(sorted_ids, axes=[1, 0])\\n ids = np.reshape(sorted_ids, (-1,))\\n\\n else:\\n ids = np.arange(data.shape[0])\\n np.random.shuffle(ids)\\n\\n if others is None:\\n return data[ids], label[ids]\\n else:\\n return data[ids], label[ids], others[ids]\",\n \"def inlabel_shuffle(data):\\n num_zero_data = np.sum(data[:,-1]==0)\\n label_zero_data = data[:num_zero_data,:]\\n label_one_data = data[num_zero_data:,:]\\n np.random.shuffle(label_zero_data)\\n np.random.shuffle(label_one_data)\\n return data\",\n \"def shuffle_dataset(self, seed=None):\\n stacked = np.r_[self.X_train,\\n self.y_train]\\n shuffle(stacked.T)\\n X_shuffled = stacked[:self.nfeatures,:]\\n y_shuffled = stacked[self.nfeatures:,:]\\n return X_shuffled, y_shuffled\",\n \"def shuffle(self):\\n self.train_nodes = np.random.permutation(self.train_nodes)\\n self.batch_num = 0\",\n \"def shuffle(self):\\n self.train_nodes = np.random.permutation(self.train_nodes)\\n self.batch_num = 0\",\n \"def shuffle(self):\\n self.train_edges = np.random.permutation(self.train_edges)\\n self.nodes = np.random.permutation(self.nodes)\\n self.batch_num = 0\",\n \"def shuffle_train(self):\\r\\n if self.data_container.task == 'Classify':\\r\\n id_train_list=[]\\r\\n for i in self.idx_train_list:\\r\\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\\r\\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\\r\\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\\r\\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\\r\\n \\r\\n self.idx['train'] = self._random_state.permutation(self.idx['train'])\",\n \"def shuffle_dataset(instances, labels, seed):\\n data = list(zip(instances, labels))\\n\\n if isinstance(seed, int):\\n random.Random(seed).shuffle(data)\\n else:\\n random.Random().shuffle(data)\\n\\n instances, labels = zip(*data)\\n\\n return instances, labels\",\n \"def shuffle_datasets(self):\\n assert self.data_tags is not None\\n assert self.training_dataset is not None\\n assert self.validation_dataset is not None\\n self.training_dataset = self.shuffle_data_dictionary(self.training_dataset)\\n self.validation_dataset = self.shuffle_data_dictionary(self.validation_dataset)\",\n \"def shuffle_T(self):\\n np.random.shuffle(self.T)\",\n \"def shuffle(self):\\n perm = self.rng.permutation(self.inputs.shape[0])\\n self._current_order = self._current_order[perm]\\n self.inputs = self.inputs[perm]\\n self.targets = self.targets[perm]\\n self.target_ids = self.target_ids[perm]\",\n \"def shuffle(self):\\n perm = self.rng.permutation(self.inputs.shape[0])\\n self._current_order = self._current_order[perm]\\n self.inputs = self.inputs[perm]\\n self.targets = self.targets[perm]\",\n \"def _shuffle(self, reinit_indexes = False):\\n print('Shuffling data...')\\n # set seed for reproducibility\\n #random.seed()\\n # shuffle identities\\n random.shuffle(self.identities)\\n # shuffle images associated to each identity\\n for identity in self.groundtruth_metadata.keys():\\n random.shuffle(self.groundtruth_metadata[identity]['metadata'])\\n if reinit_indexes:\\n self.groundtruth_metadata[identity]['index'] = 0\\n print('Finished shuffling data!')\",\n \"def shuffleData(self, x, y):\\n #get new random order for inputs and targets\\n order = np.arange( x.shape[0] )\\n random.shuffle( order )\\n #reorder inputs and targets\\n return x[order], y[order]\",\n \"def shuffle(self):\\n self.np_random.shuffle(self.deck)\",\n \"def load_data_train(self, shuffle=True):\\n\\n data, label = self._generate_all_combinations_of_stripe_images(shuffle=shuffle);\\n\\n return data, label;\",\n \"def shuffle(self, random_state=None): \\n if random_state is None:\\n random_state = self.random_state\\n perm_ids = random_state.permutation(self.n_examples)\\n self.u = self.u[perm_ids]\\n self.v = self.v[perm_ids]\\n self.rating = self.rating[perm_ids]\",\n \"def shuffled_copies(samples, labels):\\n\\n # Check if the samples and labels are from the same format\\n assert len(samples) == len(labels)\\n permu = np.random.permutation(len(samples))\\n\\n # Get the correct indexes\\n samples = samples[permu]\\n labels = labels[permu]\\n\\n return samples, labels\",\n \"def shuffle(self):\\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\\n perm = np.random.permutation(self.X_data.shape[0])\\n for old_idx, new_idx in enumerate(perm):\\n new_X[new_idx] = self.X_data[old_idx]\\n new_Y[new_idx] = self.Y_data[old_idx]\\n self.X_data = new_X\\n self.Y_data = new_Y\",\n \"def shuffle(self):\\n order = np.arange(len(self.data))\\n np.random.seed(0xA5EED)\\n np.random.shuffle(order)\\n self.data = self.data.iloc[order]\\n return order\",\n \"def shuffle(self):\\n self.edges = np.random.permutation(self.edges)\\n self.batch_num = 0\",\n \"def shuffle(data):\\n\\n shuffle = np.arange(data.shape[0])\\n np.random.shuffle(shuffle)\\n undo_shuffle = np.argsort(shuffle)\\n\\n return (data[shuffle], undo_shuffle)\",\n \"def shuffle_train_data(X_train, Y_train):\\n perm = np.random.permutation(len(Y_train))\\n Xtr_shuf = X_train[perm]\\n Ytr_shuf = Y_train[perm]\\n\\n return Xtr_shuf, Ytr_shuf\",\n \"def shuffle(self):\\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\\n if self.schema != 'default':\\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\\n\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, \\\\\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\\\\n self.neg_paths_shuffled, \\\\\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths,\\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\\n self.neg_paths_sampled,\\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\\n self.pos_paths_words, self.neg_paths_words_sampled)\\n else:\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)\",\n \"def shuffle(self):\\r\\n random.shuffle(self.deck)\",\n \"def shuffle(self):\\n random.shuffle(self.get_cards())\",\n \"def shuffle_question(self):\\n r = random.SystemRandom()\\n r.shuffle(self.question_list)\",\n \"def shuffle_data(data):\\n idx = np.arange(len(data))\\n np.random.shuffle(idx)\\n return data[idx, ...]\",\n \"def shuffle_data(data):\\n indices = list(range(data.shape[0]))\\n np.random.shuffle(indices)\\n return data[indices]\",\n \"def shuffle(self):\\n random.shuffle(self.deckcards)\",\n \"def shuffle(self):\\n shuffle(self.cards)\",\n \"def shuffle(self):\\n shuffle(self.cards)\",\n \"def shuffle(self):\\n\\t\\t\\trandom.seed(231)\\n\\t\\t\\trandom.shuffle(self.Ind)\\n\\t\\t\\tself.Ind = self.Ind[:int(len(self.Ind)/5)*5].reshape((self.cv_iters, -1))\\n\\t\\t\\t#index of valication set\\n\\t\\t\\tself.CVindex = 1\\n\\t\\t\\tself.Testindex = 0\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.SystemRandom().shuffle(self.deck)\",\n \"def shuffle(inputData):\\n\\n x = inputData[0]\\n y = inputData[1]\\n m = inputData[2]\\n \\n N = np.arange(0,x.shape[0])\\n np.random.shuffle(N)\\n \\n x = x[N,:]\\n y = y[N]\\n m = m[N,:]\\n \\n return [x,y,m]\",\n \"def shuffle_songs(self):\\n random.shuffle(self.playlist)\",\n \"def shuffle_dataset(self):\\n # TODO explain approached used for selecting training and test data\\n labels = self.dataset.label.unique()\\n good_jobs = self.dataset[self.dataset.label == \\\"Good\\\"]\\n bad_jobs = self.dataset[self.dataset.label == \\\"Bad\\\"]\\n\\n # TODO n>2 probablly won't work the way it's supposed to currently\\n if len(labels) == 2:\\n # oversample\\n resize = max(len(good_jobs.label),len(bad_jobs.label))\\n # undersample\\n resize = min(len(good_jobs.label), len(bad_jobs.label))\\n good_jobs_re = good_jobs.sample(resize)\\n bad_jobs_re = bad_jobs.sample(resize)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re])\\n elif len(labels) == 3:\\n neutral_jobs = self.dataset[self.dataset.label == \\\"Neutral\\\"]\\n # oversample\\n resize = max(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\\n # undersample\\n resize = min(len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label))\\n\\n good_jobs_re = good_jobs.sample(resize, replace=True)\\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re])\\n elif len(labels) == 4:\\n neutral_jobs = self.dataset[self.dataset.label == \\\"Neutral\\\"]\\n ideal_jobs = self.dataset[self.dataset.label == \\\"Ideal\\\"]\\n\\n # middle of the road approach\\n resize = int(mean([len(good_jobs.label), len(bad_jobs.label),len(neutral_jobs.label),len(ideal_jobs.label)]))\\n good_jobs_re = good_jobs.sample(resize, replace=True)\\n bad_jobs_re = bad_jobs.sample(resize, replace=True)\\n neutral_jobs_re = bad_jobs.sample(resize, replace=True)\\n ideal_jobs_re = ideal_jobs.sample(resize,replace=True)\\n dataset = pd.concat([good_jobs_re, bad_jobs_re,neutral_jobs_re,ideal_jobs_re])\\n\\n train,test = train_test_split(dataset,test_size=0.25,stratify = dataset.label,shuffle=True)\\n #test = self.dataset[~self.dataset.isin(train)].dropna()\\n #test = self.dataset[(~dataset.label.isin(self.dataset.label))&(~dataset.description.isin(self.dataset.description))]\\n #0tr_hashes = [hash(tuple(d)) for d in train.description]\\n #ytest = [val for iter,val in self.dataset.iterrows() if hash(tuple(val.description)) not in tr_hashes]\\n\\n self.y_train,self.y_test = train.label.values,test.label.values\\n self.X_train,self.X_test = train.description.values,test.description.values\",\n \"def shuffle_data(y, data):\\n combined = np.c_[data.reshape(len(data), -1), y.reshape(len(y), -1)]\\n np.random.shuffle(combined)\\n shuffled_data = combined[:, :data.size // len(data)].reshape(data.shape)\\n shuffled_y = combined[:, data.size // len(data):].reshape(y.shape)\\n return [shuffled_y, shuffled_data]\",\n \"def shuffle(self):\\n reorder(self.cards) #importing shuffle as reorder\",\n \"def shuffle(self):\\n self.shuffle_range(len(self.cards))\",\n \"def shuffle(self):\\n import random\\n random.shuffle(self.cards)\",\n \"def _shuffle():\\n\\n random.shuffle(deck)\",\n \"def shuffle(self) -> None:\\r\\n random.shuffle(self._deck)\",\n \"def shuffle(self):\\n for i in range(10):\\n random.shuffle(self.set)\",\n \"def shuffle( self ):\\n random.shuffle(self.__deck)\",\n \"def shuffle(self, x_data, y_data, samples, x_fields, y_fields, swaps_g=None):\\n if swaps_g is None:\\n swaps_np = np.arange(samples, dtype=cltypes.uint)\\n np.random.shuffle(swaps_np)\\n swaps_g = array.to_device(self.queue, swaps_np, allocator=self.read_only_arr)\\n # print(\\\"swaps:\\\", swaps_g.get())\\n e1 = self.shuffle_krnl(self.queue, (x_fields, samples // 2), None, x_data, swaps_g.data)\\n e2 = self.shuffle_krnl(self.queue, (y_fields, samples // 2), None, y_data, swaps_g.data)\\n e1.wait()\\n e2.wait()\",\n \"def load_data_and_labels_without_shuffled():\\n # Load data from files\\n with codecs.open('./data/train_pos.txt', 'r+', 'utf-8') as f:\\n train_pos = f.readlines()\\n with codecs.open('./data/dev_pos.txt', 'r+', 'utf-8') as f:\\n dev_pos = f.readlines()\\n with codecs.open('./data/train_neg.txt', 'r+', 'utf-8') as f:\\n train_neg = f.readlines()\\n with codecs.open('./data/dev_neg.txt', 'r+', 'utf-8') as f:\\n dev_neg = f.readlines()\\n\\n positive_examples1 = []\\n positive_examples2 = []\\n negative_examples1 = []\\n negative_examples2 = []\\n\\n for i in train_pos:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n positive_examples1.append(item1)\\n positive_examples2.append(item2)\\n\\n for i in train_neg:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n negative_examples1.append(item1)\\n negative_examples2.append(item2)\\n\\n # Split by words\\n x_text_train1 = positive_examples1 + negative_examples1\\n x_text_train2 = positive_examples2 + negative_examples2\\n\\n positive_dev1 = []\\n positive_dev2 = []\\n negative_dev1 = []\\n negative_dev2 = []\\n\\n for i in dev_pos:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n positive_dev1.append(item1)\\n positive_dev2.append(item2)\\n\\n for i in dev_neg:\\n item1, item2 = i.split('\\\\t')\\n item1 = remove_stop_word(item1)\\n item2 = remove_stop_word(item2)\\n negative_dev1.append(item1)\\n negative_dev2.append(item2)\\n\\n x_text_dev1 = positive_dev1 + negative_dev1\\n x_text_dev2 = positive_dev2 + negative_dev2\\n\\n # Generate labels\\n train_positive_labels = [[0, 1] for _ in train_pos]\\n dev_positive_labels = [[0, 1] for _ in dev_pos]\\n train_negative_labels = [[1, 0] for _ in train_neg]\\n dev_negative_labels = [[1, 0] for _ in dev_neg]\\n y_train = np.concatenate([train_positive_labels, train_negative_labels], 0)\\n y_dev = np.concatenate([dev_positive_labels, dev_negative_labels], 0)\\n\\n return [x_text_train1, x_text_train2, x_text_dev1, x_text_dev2, y_train, y_dev]\",\n \"def shuffle(self) -> None:\\n shuffle(self.cards)\",\n \"def shuffle(self) -> NoReturn:\\n for edge_type in self.edge_types:\\n for edge_class in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][edge_class] = np.random.permutation(\\n self.train_edges[edge_type][edge_class])\\n\\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\\n for edge_type, edge_class in self.edge_types.items()}\\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\\n self.edge_types.items()}\\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\\n self.iter = 0\",\n \"def shuffle_data(X, y, seed=None):\\n if seed:\\n np.random.seed(seed)\\n idx = np.arange(X.shape[0])\\n np.random.shuffle(idx)\\n return X[idx], y[idx]\",\n \"def shuffle_data(X, y, seed=None):\\n if seed:\\n np.random.seed(seed)\\n idx = np.arange(X.shape[0])\\n np.random.shuffle(idx)\\n return X[idx], y[idx]\",\n \"def shuffle_data(X, y, seed=None):\\n if seed:\\n np.random.seed(seed)\\n idx = np.arange(X.shape[0])\\n np.random.shuffle(idx)\\n return X[idx], y[idx]\",\n \"def prepare_imdb_data(data, labels, should_shuffle=True):\\n\\n #Combine positive and negative reviews and labels\\n data_train = data['train']['pos'] + data['train']['neg']\\n data_test = data['test']['pos'] + data['test']['neg']\\n labels_train = labels['train']['pos'] + labels['train']['neg']\\n labels_test = labels['test']['pos'] + labels['test']['neg']\\n\\n #Shuffle reviews and corresponding labels within training and test sets\\n if should_shuffle:\\n data_train, labels_train = shuffle(data_train, labels_train)\\n data_test, labels_test = shuffle(data_test, labels_test)\\n\\n # Return a unified training data, test data, training labels, test labets\\n return data_train, data_test, labels_train, labels_test\",\n \"def random_preprocessing(inputs, labels):\\r\\n indices = range(0, labels.shape[0])\\r\\n shuffled_indices = tf.random.shuffle(indices)\\r\\n inputs = tf.gather(inputs, shuffled_indices)\\r\\n labels = tf.gather(labels, shuffled_indices)\\r\\n return inputs, labels\",\n \"def shuffle_data(X, Y):\\n m, nx = Y.shape\\n shuffled = np.random.permutation(m)\\n X_shuffled = X[shuffled]\\n Y_shuffled = Y[shuffled]\\n return X_shuffled, Y_shuffled\",\n \"def shuffle(input_dataset, target_dataset):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\t\\tassert(input_dataset.shape[0] == target_dataset.shape[0])\\n\\t\\t\\n\\t\\tperm = np.random.permutation(input_dataset.shape[0])\\n\\n\\t\\treturn input_dataset[perm], target_dataset[perm]\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def shuffle(self, random_seed: int = 0):\\n # shuffle feature model clauses (used for div. promotion)\\n random.seed(random_seed)\\n clauses_ = []\\n for clause in self.clauses_raw:\\n clause_ = random.sample(clause, len(clause))\\n clauses_.append(clause_)\\n clauses = random.sample(clauses_, len(clauses_))\\n \\n self.clauses, self.target = FeatureModel.__convert_dimacs_to_bitvec(clauses, len(self.feature_dict))\",\n \"def next_batch(num, data, labels):\\n idx = np.arange(0 , len(data))\\n np.random.shuffle(idx)\\n idx = idx[:num]\\n data_shuffle = [data[i] for i in idx]\\n labels_shuffle = [labels[i] for i in idx]\\n\\n return np.asarray(data_shuffle), np.asarray(labels_shuffle)\",\n \"def _shuffle(inputs):\\n\\texpand_inputs = tf.stack(inputs, axis = -1)\\n\\tshuffled_inputs = tf.random_shuffle(expand_inputs)\\n\\treturn tf.unstack(shuffled_inputs)\",\n \"def data_loader(self, dataset=None, shuffle=True, size=None):\\n self.log.info(\\\"Loading data\\\")\\n assert dataset is not None, \\\"Please provide a dataset (folder name)\\\"\\n data_path = os.path.join(config.DATA_DIR, dataset)\\n # Load dataset using pickle\\n with open(data_path, 'rb') as file:\\n image_paths, labels = pickle.load(file)\\n one_hot_labels = []\\n images = []\\n for i, (path, label) in enumerate(zip(image_paths, labels)):\\n try:\\n # One-hot encode the vectors\\n one_hot = [0, 0, 0, 0]\\n one_hot[label] = 1.0\\n # Clean up image, normalize (mean to 0, std to 1)\\n image = Image.open(path)\\n image = np.asarray(image, dtype=np.float32) / 255\\n except: # If there is some issue reading in data, skip datapoint\\n continue\\n one_hot_labels.append(np.asarray(one_hot, dtype=np.float32))\\n images.append(image)\\n # Shuffle data before cutting it into test and src\\n if shuffle:\\n x = list(zip(images, one_hot_labels))\\n random.shuffle(x)\\n images, one_hot_labels = zip(*x)\\n self.log.info(\\\"Separating data into test and src.\\\")\\n split_idx = int(config.TRAIN_TEST_SPLIT * len(one_hot_labels))\\n train_input = images[:split_idx]\\n train_target = one_hot_labels[:split_idx]\\n test_input = images[split_idx:]\\n test_target = one_hot_labels[split_idx:]\\n if size:\\n assert size < len(train_input), \\\"Final dataset size too big, not enough data\\\"\\n train_input = train_input[:size]\\n train_target = train_target[:size]\\n self.log.info(\\\" -- test : {}\\\".format(len(test_target)))\\n self.log.info(\\\" -- src: {}\\\".format(len(train_target)))\\n # Convert to nparray before sending over\\n return np.array(train_input), \\\\\\n np.array(train_target), \\\\\\n np.array(test_input), \\\\\\n np.array(test_target)\",\n \"def shuffle(self):\\n for edge_type in self.edge_types:\\n for k in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\\n self.current_edge_type_idx = 0\\n self.freebatch_edge_types = list(range(self.num_edge_types))\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\\n self.iter = 0\",\n \"def _shuffle(x, y):\\n ind = np.arange(y.shape[0])\\n np.random.shuffle(ind)\\n\\n return x[:, ind, :], y[ind]\",\n \"def next_batch(num, data, labels):\\n idx = np.arange(0, len(data))\\n np.random.shuffle(idx)\\n idx = idx[:num]\\n data_shuffle = [data[i] for i in idx]\\n labels_shuffle = [labels[i] for i in idx]\\n \\n return np.asarray(data_shuffle), np.asarray(labels_shuffle)\",\n \"def __shuffle_cards(self):\\n random.shuffle(self.cards)\",\n \"def shuffle_and_split_data(X_genesets, y, train_size, validate_size):\\n permutation = np.random.permutation(y.size)\\n y_permuted = y[permutation]\\n X_genesets_permuted = [Xg[permutation, :] for Xg in X_genesets]\\n X_groups_train = [Xg[0:train_size, :] for Xg in X_genesets_permuted]\\n X_groups_validate = [Xg[train_size: validate_size + train_size, :] for Xg in X_genesets_permuted]\\n X_groups_test = [Xg[validate_size + train_size:, :] for Xg in X_genesets_permuted]\\n y_train = y_permuted[0:train_size]\\n y_validate = y_permuted[train_size: validate_size + train_size]\\n y_test = y_permuted[validate_size + train_size:]\\n return X_groups_train, y_train, X_groups_validate, y_validate, X_groups_test, y_test\",\n \"def shuffle(self, inp: Tensor):\\n _seed = self._seed() if callable(self._seed) else self._seed\\n inp._reset(_shuffle(inp=inp, seed=_seed, handle=self._handle))\",\n \"def randomize(data):\\r\\n permutation = np.random.permutation(data.shape[0])\\r\\n shuffled_data = data[permutation, :]\\r\\n # shuffled_y = y[permutation]\\r\\n return shuffled_data\",\n \"def Shuffle(self):\\r\\n random.shuffle(self.cards_list)\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:,idx,:]\",\n \"def _shuffle(self):\\n print \\\"Shuffled the bag\\\"\\n # The 'random' library provides a really handy function we can\\n # use called 'shuffle'. You provide 'shuffle' with a\\n # 'sequence' (basically, a list) and the shuffle function\\n # randomizes the placement of all items in the sequence\\n # automatically. There is no return value from\\n # \\\"random.shuffle\\\" because \\\"self.bag\\\" is modified in place.\\n random.shuffle(self.bag)\",\n \"def shuffle(self):\\n index = list(range(self.k))\\n random.shuffle(index)\\n for i, j in enumerate(index):\\n self.list[i] = self.dic[j]\\n return self.list\",\n \"def shuffle(lol, seed):\\n for l in lol:\\n random.seed(seed)\\n random.shuffle(l)\",\n \"def main():\\n input_1 = [7, 6, 5, 4, 3, 2, 1]\\n print shuffle(input_1)\\n print input_1\",\n \"def shuffle_in_unison(self, x_train, y_train,split=0.1):\\n n = np.size(x_train,axis=0)\\n p = np.random.permutation(len(x_train))\\n cutoff = int(split*n)\\n p_val = p[0:cutoff]\\n p_train = p[cutoff:]\\n return x_train[p_train], y_train[p_train], x_train[p_val], y_train[p_val]\",\n \"def _oversample(self, imgs_paths):\\n # Split by label\\n labels = [bool(self._get_img_label(path)) for path in imgs_paths]\\n without_tomato = imgs_paths[np.invert(labels)]\\n with_tomato = imgs_paths[labels]\\n\\n # Augment the dataset by transformation\\n internal_transforms = [\\n None,\\n T.RandomHorizontalFlip(1),\\n T.RandomVerticalFlip(1),\\n RotationTransform(-90),\\n RotationTransform(90)\\n ]\\n\\n paths_transforms = [\\n (path, transform)\\n for path in with_tomato\\n for transform in internal_transforms\\n ] + [(path, None) for path in without_tomato]\\n\\n result = np.array(paths_transforms)\\n np.random.shuffle(result)\\n return result\",\n \"def sample_models(self):\\n label_sets = []\\n free_labels = xrange(self.label_count)\\n \\n while len(label_sets) < self.model_count:\\n label_set = random.sample(free_labels, self.labelset_size)\\n if label_set not in label_sets:\\n label_sets.append(label_set)\\n\\n self.label_sets = label_sets\",\n \"def reset(self):\\n self.epochs = 0\\n # Shuffle the training data\\n perm = np.arange(self.num_train)\\n np.random.shuffle(perm)\\n assert self.num_train == self.train_images.shape[\\n 0], 'Error incorrect shuffling mask'\\n self.train_images = self.train_images[perm]\\n self.train_labels = self.train_labels[perm]\\n self.curr_train_index = 0\",\n \"def shuffle(data, shuffle_size=10000):\\n buf = []\\n for sample in data:\\n buf.append(sample)\\n if len(buf) >= shuffle_size:\\n random.shuffle(buf)\\n for x in buf:\\n yield x\\n buf = []\\n # The sample left over\\n random.shuffle(buf)\\n for x in buf:\\n yield x\",\n \"def shuffle_mode(self, shuffle=True):\\n self._shuffle = shuffle\",\n \"def next_batch_shuffle(self, batch_size):\\n\\tperm0 = np.arange(self.TRAIN_SIZE)\\n np.random.shuffle(perm0)\\n self.data['x_train'], self.data['y_train'] = self.data['x_train'][perm0,:], self.data['y_train'][perm0,:]\\n\\treturn self.data['x_train'][:batch_size], self.data['y_train'][:batch_size]\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def _shuffle(self, r, idx_to_shuffle = None):\\n n_features = r.shape[0]\\n n_trials = r.shape[1]\\n r_sh = r\\n if idx_to_shuffle is None:\\n idx_to_shuffle = range(n_features)\\n for i in range(n_features):\\n if i in idx_to_shuffle:\\n r_sh[i,:] = r[i,random.permutation(range(n_trials))]\\n return r_sh\",\n \"def shuffle_data(X,y,z):\\n data = np.row_stack((X, y, z))\\n np.random.shuffle(data.T)\\n X = data[:-2,:]\\n y = data[-2,:]\\n z = data[-1,:]\\n\\n return X, y, z\",\n \"def batch_generator(batch_size, data, labels=None):\\n n_batches = int(np.ceil(len(data) / float(batch_size)))\\n idx = np.random.permutation(len(data))\\n data_shuffled = data[idx]\\n if labels is not None:\\n labels_shuffled = labels[idx]\\n for i in range(n_batches):\\n start = i * batch_size\\n end = start + batch_size\\n if labels is not None:\\n yield data_shuffled[start:end, :], labels_shuffled[start:end]\\n else:\\n yield data_shuffled[start:end, :]\",\n \"def shuffle_aligned_list(data):\\n num = data[0].shape[0]\\n p = np.random.permutation(num)\\n return [d[p] for d in data]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84921646","0.84220874","0.800393","0.7868807","0.78123","0.7764462","0.7758387","0.76847744","0.7454648","0.74520284","0.7394949","0.7394949","0.73529667","0.72944164","0.7293919","0.7201344","0.7141838","0.70985335","0.7062494","0.70317477","0.69610476","0.6940233","0.68803275","0.68589514","0.6858393","0.6854256","0.682621","0.67958546","0.6784707","0.66917175","0.66704726","0.6646246","0.66397303","0.66263604","0.6604832","0.65993017","0.65825903","0.6579511","0.6579511","0.65783596","0.65699846","0.65699846","0.65699846","0.65699846","0.65699846","0.6562261","0.6527375","0.652436","0.65171397","0.6495875","0.64927936","0.64418393","0.6439664","0.6410732","0.64094275","0.6357312","0.6352148","0.6305173","0.6296794","0.62900984","0.62706894","0.6267874","0.6267874","0.6267874","0.6258262","0.6244891","0.62354434","0.62140214","0.61789846","0.61469156","0.61444384","0.6126217","0.61256045","0.6105055","0.6082516","0.6076912","0.60624963","0.60569066","0.6054195","0.6049803","0.60471165","0.60460484","0.6031822","0.60314596","0.6030091","0.6006567","0.60050267","0.6002051","0.60001403","0.5999162","0.59811616","0.59810525","0.59789014","0.597801","0.597116","0.5962666","0.59498405","0.5945454"],"string":"[\n \"0.84921646\",\n \"0.84220874\",\n \"0.800393\",\n \"0.7868807\",\n \"0.78123\",\n \"0.7764462\",\n \"0.7758387\",\n \"0.76847744\",\n \"0.7454648\",\n \"0.74520284\",\n \"0.7394949\",\n \"0.7394949\",\n \"0.73529667\",\n \"0.72944164\",\n \"0.7293919\",\n \"0.7201344\",\n \"0.7141838\",\n \"0.70985335\",\n \"0.7062494\",\n \"0.70317477\",\n \"0.69610476\",\n \"0.6940233\",\n \"0.68803275\",\n \"0.68589514\",\n \"0.6858393\",\n \"0.6854256\",\n \"0.682621\",\n \"0.67958546\",\n \"0.6784707\",\n \"0.66917175\",\n \"0.66704726\",\n \"0.6646246\",\n \"0.66397303\",\n \"0.66263604\",\n \"0.6604832\",\n \"0.65993017\",\n \"0.65825903\",\n \"0.6579511\",\n \"0.6579511\",\n \"0.65783596\",\n \"0.65699846\",\n \"0.65699846\",\n \"0.65699846\",\n \"0.65699846\",\n \"0.65699846\",\n \"0.6562261\",\n \"0.6527375\",\n \"0.652436\",\n \"0.65171397\",\n \"0.6495875\",\n \"0.64927936\",\n \"0.64418393\",\n \"0.6439664\",\n \"0.6410732\",\n \"0.64094275\",\n \"0.6357312\",\n \"0.6352148\",\n \"0.6305173\",\n \"0.6296794\",\n \"0.62900984\",\n \"0.62706894\",\n \"0.6267874\",\n \"0.6267874\",\n \"0.6267874\",\n \"0.6258262\",\n \"0.6244891\",\n \"0.62354434\",\n \"0.62140214\",\n \"0.61789846\",\n \"0.61469156\",\n \"0.61444384\",\n \"0.6126217\",\n \"0.61256045\",\n \"0.6105055\",\n \"0.6082516\",\n \"0.6076912\",\n \"0.60624963\",\n \"0.60569066\",\n \"0.6054195\",\n \"0.6049803\",\n \"0.60471165\",\n \"0.60460484\",\n \"0.6031822\",\n \"0.60314596\",\n \"0.6030091\",\n \"0.6006567\",\n \"0.60050267\",\n \"0.6002051\",\n \"0.60001403\",\n \"0.5999162\",\n \"0.59811616\",\n \"0.59810525\",\n \"0.59789014\",\n \"0.597801\",\n \"0.597116\",\n \"0.5962666\",\n \"0.59498405\",\n \"0.5945454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77576107"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":9462,"cells":{"query":{"kind":"string","value":"Shuffle orders of points in each point cloud changes FPS behavior. Use the same shuffling idx for the entire batch."},"document":{"kind":"string","value":"def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]"},"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 shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def _shuffle_roidb_idx(self):\n self.perm = np.random.permutation(np.arange(self.num_images))\n self.cur = 0","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def shuffle(self, idx=None):\n for i in [idx] if idx is not None else range(self.num_buckets):\n self.buckets[i] = self.buckets[i].sample(frac=1).reset_index(drop=True)\n self.cursor[i] = 0","def _batch_shuffle_ddp(self, x):\n # gather from all gpus\n batch_size_this = x.shape[0]\n x_gather = concat_all_gather(x)\n batch_size_all = x_gather.shape[0]\n\n num_gpus = batch_size_all // batch_size_this\n\n # random shuffle index\n idx_shuffle = torch.randperm(batch_size_all).cuda()\n\n # broadcast to all gpus\n torch.distributed.broadcast(idx_shuffle, src=0)\n\n # index for restoring\n idx_unshuffle = torch.argsort(idx_shuffle)\n\n # shuffled index for this gpu\n gpu_idx = torch.distributed.get_rank()\n idx_this = idx_shuffle.view(num_gpus, -1)[gpu_idx]\n\n return x_gather[idx_this], idx_unshuffle","def shuffle(self):\n self.train_nodes = np.random.permutation(self.train_nodes)\n self.batch_num = 0","def shuffle(self):\n self.train_nodes = np.random.permutation(self.train_nodes)\n self.batch_num = 0","def _shuffle(self, reinit_indexes = False):\n print('Shuffling data...')\n # set seed for reproducibility\n #random.seed()\n # shuffle identities\n random.shuffle(self.identities)\n # shuffle images associated to each identity\n for identity in self.groundtruth_metadata.keys():\n random.shuffle(self.groundtruth_metadata[identity]['metadata'])\n if reinit_indexes:\n self.groundtruth_metadata[identity]['index'] = 0\n print('Finished shuffling data!')","def shuffle(self):\n self.train_edges = np.random.permutation(self.train_edges)\n self.nodes = np.random.permutation(self.nodes)\n self.batch_num = 0","def shuffle(self):\n self.edges = np.random.permutation(self.edges)\n self.batch_num = 0","def shuffle_data(self):\n images = list(self.train_images)\n labels = list(self.train_labels)\n self.train_images = []\n self.train_labels = []\n\n # create list of permutated index and shuffle data accoding to list\n idx = np.random.permutation(len(labels))\n for i in idx:\n self.train_images.append(images[i])\n self.train_labels.append(labels[i])","def _shuffle(self, r, idx_to_shuffle = None):\n n_features = r.shape[0]\n n_trials = r.shape[1]\n r_sh = r\n if idx_to_shuffle is None:\n idx_to_shuffle = range(n_features)\n for i in range(n_features):\n if i in idx_to_shuffle:\n r_sh[i,:] = r[i,random.permutation(range(n_trials))]\n return r_sh","def shuffle_T(self):\n np.random.shuffle(self.T)","def next_batch_shuffle(self, batch_size):\n\tperm0 = np.arange(self.TRAIN_SIZE)\n np.random.shuffle(perm0)\n self.data['x_train'], self.data['y_train'] = self.data['x_train'][perm0,:], self.data['y_train'][perm0,:]\n\treturn self.data['x_train'][:batch_size], self.data['y_train'][:batch_size]","def shuffle(self):\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\n perm = np.random.permutation(self.X_data.shape[0])\n for old_idx, new_idx in enumerate(perm):\n new_X[new_idx] = self.X_data[old_idx]\n new_Y[new_idx] = self.Y_data[old_idx]\n self.X_data = new_X\n self.Y_data = new_Y","def shuffle(self):\n\t\t\trandom.seed(231)\n\t\t\trandom.shuffle(self.Ind)\n\t\t\tself.Ind = self.Ind[:int(len(self.Ind)/5)*5].reshape((self.cv_iters, -1))\n\t\t\t#index of valication set\n\t\t\tself.CVindex = 1\n\t\t\tself.Testindex = 0","def shuffle_train(self):\r\n if self.data_container.task == 'Classify':\r\n id_train_list=[]\r\n for i in self.idx_train_list:\r\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\r\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\r\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\r\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\r\n \r\n self.idx['train'] = self._random_state.permutation(self.idx['train'])","def shuffle(self):\n for edge_type in self.edge_types:\n for k in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\n self.current_edge_type_idx = 0\n self.freebatch_edge_types = list(range(self.num_edge_types))\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\n self.iter = 0","def shuffle(self):\n order = np.arange(len(self.data))\n np.random.seed(0xA5EED)\n np.random.shuffle(order)\n self.data = self.data.iloc[order]\n return order","def shuffle(self):\n self.x['train'], self.y['train'] = self._shuffle(\n self.x['train'],\n self.y['train']\n )","def shuffle(self, random_state=None): \n if random_state is None:\n random_state = self.random_state\n perm_ids = random_state.permutation(self.n_examples)\n self.u = self.u[perm_ids]\n self.v = self.v[perm_ids]\n self.rating = self.rating[perm_ids]","def on_epoch_end(self):\n if self.shuffle:\n self.indexes = np.random.permutation(self.indexes)","def on_epoch_end(self):\n if self.shuffle:\n self.indexes = np.random.permutation(self.indexes)","def shuffle(self):\n perm = self.rng.permutation(self.inputs.shape[0])\n self._current_order = self._current_order[perm]\n self.inputs = self.inputs[perm]\n self.targets = self.targets[perm]","def _batch_shuffle_single_gpu(self, x):\n # random shuffle index\n idx_shuffle = torch.randperm(x.shape[0]).cuda()\n\n # index for restoring\n idx_unshuffle = torch.argsort(idx_shuffle)\n\n return x[idx_shuffle], idx_unshuffle","def shuffle(self):\n perm = self.rng.permutation(self.inputs.shape[0])\n self._current_order = self._current_order[perm]\n self.inputs = self.inputs[perm]\n self.targets = self.targets[perm]\n self.target_ids = self.target_ids[perm]","def post_randomize(self):\n super(BatchRandomizer, self).post_randomize()\n self.batch_idx += 1","def on_epoch_end(self):\n if self.shuffle:\n np.random.shuffle(self.indices)","def on_epoch_end(self):\n if self.shuffle:\n np.random.shuffle(self.indexes)","def _shuffle_roidb_inds(self):\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\n self._cur = 0","def shuffle(self):\n for i in range(10):\n random.shuffle(self.set)","def on_epoch_end(self):\n if self.is_train:\n np.random.shuffle(self.image_indexes)","def shuffle(self):\n self.np_random.shuffle(self.deck)","def on_epoch_end(self):\n if self.shuffle == True:\n numpy.random.shuffle(self.indexes)","def _batch_unshuffle_ddp(self, x, idx_unshuffle):\n # gather from all gpus\n batch_size_this = x.shape[0]\n x_gather = concat_all_gather(x)\n batch_size_all = x_gather.shape[0]\n\n num_gpus = batch_size_all // batch_size_this\n\n # restored index for this gpu\n gpu_idx = torch.distributed.get_rank()\n idx_this = idx_unshuffle.view(num_gpus, -1)[gpu_idx]\n\n return x_gather[idx_this]","def shuffle_dataset(self, seed=None):\n stacked = np.r_[self.X_train,\n self.y_train]\n shuffle(stacked.T)\n X_shuffled = stacked[:self.nfeatures,:]\n y_shuffled = stacked[self.nfeatures:,:]\n return X_shuffled, y_shuffled","def shuffle(self):\n reorder(self.cards) #importing shuffle as reorder","def _compute_indices(self):\n self.indices = np.arange(len(self.im_filenames))\n np.random.shuffle(self.indices)","def order_batch(store_name, x=4):\n for i in range(x):\n random_order(store_name)","def batch_shuffle(index_array, batch_size):\n batch_count = int(len(index_array) / batch_size)\n # to reshape we need to be cleanly divisible by batch size\n # we stash extra items and reappend them after shuffling\n last_batch = index_array[batch_count * batch_size:]\n index_array = index_array[:batch_count * batch_size]\n index_array = index_array.reshape((batch_count, batch_size))\n np.random.shuffle(index_array)\n index_array = index_array.flatten()\n return np.append(index_array, last_batch)","def on_epoch_end(self):\n if self.shuffle:\n p = np.random.permutation(len(self.X))\n self.X = self.X[p]\n self.y = self.y[p]","def shuffle(self):\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\n if self.schema != 'default':\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\n\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, \\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\n self.neg_paths_shuffled, \\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths,\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\n self.neg_paths_sampled,\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\n self.pos_paths_words, self.neg_paths_words_sampled)\n else:\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)","def shuffle(self):\n self.__c_elem().melange()","def on_epoch_end(self):\n if self.shuffle:\n self.indices = np.random.permutation(self._len)","def shuffle(self):\n self.shuffle_range(len(self.cards))","def _shuffle_roidb_inds(self):\n ## 设置cur来指向现在访问的长度\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\n self._cur = 0","def get_next_batch(self):\n if self.index_in_epoch + self.batch_size > self.X.shape[0]:\n idx = np.arange(0, self.X.shape[0])\n self.index_in_epoch = 0\n np.random.shuffle(idx)\n self.X = self.X[idx]\n self.y = self.y[idx]\n # idx = idx[self.index_in_epoch:self.index_in_epoch + self.batch_size]\n # data_shuffle = [self.X[i] for i in idx]\n # labels_shuffle = [self.y[i] for i in idx]\n # data_shuffle = np.asarray(data_shuffle)\n # data_shuffle = np.reshape(data_shuffle, newshape=(self.batch_size, 1024))\n #\n # labels_shuffle = np.asarray(labels_shuffle)\n # labels_shuffle = np.reshape(labels_shuffle, newshape=(self.batch_size, 26))\n data_shuffle = self.X[self.index_in_epoch:self.index_in_epoch + self.batch_size, :]\n data_shuffle = np.reshape(data_shuffle, newshape=(self.batch_size, 32, 32, 1))\n labels_shuffle = self.y[self.index_in_epoch:self.index_in_epoch + self.batch_size, :]\n labels_shuffle = np.reshape(labels_shuffle, newshape=(self.batch_size, 26))\n self.index_in_epoch += self.batch_size\n return data_shuffle, labels_shuffle","def _shuffle():\n\n random.shuffle(deck)","def shuffle(self):\n index = list(range(self.k))\n random.shuffle(index)\n for i, j in enumerate(index):\n self.list[i] = self.dic[j]\n return self.list","def _shuffle_roidb_inds(self):\r\n if True: #cfg.TRAIN.ASPECT_GROUPING:\r\n widths = np.array([r['width'] for r in self._roidb])\r\n heights = np.array([r['height'] for r in self._roidb])\r\n horz = (widths >= heights)\r\n vert = np.logical_not(horz)\r\n horz_inds = np.where(horz)[0]\r\n vert_inds = np.where(vert)[0]\r\n\r\n horz_inds = np.random.permutation(horz_inds)\r\n vert_inds = np.random.permutation(vert_inds)\r\n mb = 2 #cfg.TRAIN.IMS_PER_BATCH\r\n horz_inds = horz_inds[:(len(horz_inds) // mb) * mb]\r\n vert_inds = vert_inds[:(len(vert_inds) // mb) * mb]\r\n inds = np.hstack((horz_inds, vert_inds))\r\n\r\n inds = np.reshape(inds, (-1, mb))\r\n row_perm = np.random.permutation(np.arange(inds.shape[0]))\r\n inds = np.reshape(inds[row_perm, :], (-1, ))\r\n self._perm = inds\r\n else:\r\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\r\n self._perm = deque(self._perm)\r\n self._cur = 0","def shuffle(self):\r\n self._current = 0\r\n random.shuffle(self._cards)","def shuffle(self):\n self.logger.debug('Shuffling wallpaper queue')\n\n random.shuffle(self.wallpapers)\n self.index = 0","def shuffle(self):\n for i in xrange(self.n - 1):\n pos = random.randint(i, self.n - 1)\n self.to[i], self.to[pos] = self.to[pos], self.to[i]\n self.a[i], self.a[pos] = self.a[pos], self.a[i]\n return self.a","def shuffle(self):\r\n random.shuffle(self.deck)","def shuffle(self) -> List[int]:\n for i in range(len(self.array)):\n tmp_idx = randrange(i, len(self.array))\n self.array[i], self.array[tmp_idx] = self.array[tmp_idx], self.array[i]\n return self.array","def shuffle(self):\r\n #\r\n shuffled_seed = copy.deepcopy(self)\r\n #\r\n # for each location [x0][y0], randomly choose another location\r\n # [x1][y1] and swap the values of the cells in the two locations.\r\n #\r\n for x0 in range(self.xspan):\r\n for y0 in range(self.yspan):\r\n x1 = rand.randrange(self.xspan)\r\n y1 = rand.randrange(self.yspan)\r\n temp = shuffled_seed.cells[x0][y0]\r\n shuffled_seed.cells[x0][y0] = shuffled_seed.cells[x1][y1]\r\n shuffled_seed.cells[x1][y1] = temp\r\n #\r\n return shuffled_seed","def Shuffle(self):\r\n random.shuffle(self.cards_list)","def generate_shuffle(self):\n self._shuffle_list = range(len(self._playlist))\n random.shuffle(self._shuffle_list)\n if self._active_index in self._shuffle_list:\n self._shuffle_list.remove(self._active_index)","def shuffle_priors(self):\n\n if self.shuffle_prior_axis is None:\n return None\n elif self.shuffle_prior_axis == 0:\n # Shuffle index (genes) in the priors_data\n utils.Debug.vprint(\"Randomly shuffling prior [{sh}] gene data\".format(sh=self.priors_data.shape))\n prior_index = self.priors_data.index.tolist()\n self.priors_data = self.priors_data.sample(frac=1, axis=0, random_state=self.random_seed)\n self.priors_data.index = prior_index\n elif self.shuffle_prior_axis == 1:\n # Shuffle columns (TFs) in the priors_data\n utils.Debug.vprint(\"Randomly shuffling prior [{sh}] TF data\".format(sh=self.priors_data.shape))\n prior_index = self.priors_data.columns.tolist()\n self.priors_data = self.priors_data.sample(frac=1, axis=1, random_state=self.random_seed)\n self.priors_data.columns = prior_index\n else:\n raise ValueError(\"shuffle_prior_axis must be 0 or 1\")","def point_random_position(self, point_distribution, mask):\n batch_size = point_distribution.size(0)\n mask_np = to_np(mask) # batch x time\n indices = []\n for i in range(batch_size):\n msk = mask_np[i] # time\n indices.append(np.random.choice(len(msk), 2, p=msk / np.sum(msk, -1)))\n indices = to_pt(np.stack(indices, 0), self.use_cuda) # batch x 2\n return indices","def shuffle(self):\n random.shuffle(self.get_cards())","def __getitem__(self, idx):\n index = lambda x: x[idx * self.batch_size:(idx + 1) * self.batch_size]\n batch_questions = index(self.questions_shuffled) # Shape (batch, seqlen)\n batch_questions_dep = index(self.questions_dep_shuffled) #Shape (batch, seqlen)\n batch_questions_dep_mask = index(self.questions_dep_mask_shuffled) #Shape (batch, seqlen)\n batch_pos_paths = index(self.pos_paths_shuffled) # Shape (batch, seqlen)\n batch_pos_paths_words = index(self.pos_paths_words_shuffled) # Shape (batch, seqlen)\n batch_neg_paths = index(self.neg_paths_shuffled) # Shape (batch, seqlen)\n batch_neg_paths_words = index(self.neg_paths_words_shuffled) # Shape (batch, seqlen)\n if self.schema != 'default':\n batch_neg_paths_rel1 = index(self.neg_paths_rel1_shuffled) # Shape (batch, seqlen)\n batch_neg_paths_rel2 = index(self.neg_paths_rel2_shuffled) # Shape (batch, seqlen)\n batch_neg_paths_rel3 = index(self.neg_paths_rel3_shuffled) # Shape (batch, seqlen)\n batch_neg_paths_rel4 = index(self.neg_paths_rel4_shuffled) # Shape (batch, seqlen)\n batch_pos_paths_rel1 = index(self.pos_paths_rel1_shuffled) # Shape (batch, seqlen)\n batch_pos_paths_rel2 = index(self.pos_paths_rel2_shuffled) # Shape (batch, seqlen)\n batch_pos_paths_rel3 = index(self.pos_paths_rel3_shuffled) # Shape (batch, seqlen)\n batch_pos_paths_rel4 = index(self.pos_paths_rel4_shuffled) # Shape (batch, seqlen)\n\n if self.schema == 'default':\n return ([batch_questions, batch_questions_dep, batch_questions_dep_mask,\n batch_pos_paths, batch_neg_paths,\n batch_pos_paths_words,batch_neg_paths_words], self.dummy_y)\n else:\n return ([batch_questions, batch_questions_dep, batch_questions_dep_mask,\n batch_pos_paths,\n batch_pos_paths_rel1,batch_pos_paths_rel2,batch_pos_paths_rel3,batch_pos_paths_rel4,\n batch_neg_paths,\n batch_neg_paths_rel1,batch_neg_paths_rel2,batch_neg_paths_rel3,batch_neg_paths_rel4,\n batch_pos_paths_words,batch_neg_paths_words], self.dummy_y)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self):\n random.shuffle(self.cards)","def shuffle(self) -> List[int]:","def _random_permutation(self):\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))","def shuffle(self):\n shuffle(self.cards)","def shuffle(self):\n shuffle(self.cards)","def __new_epoch(self):\n self.epoch += 1\n indices = np.arange(self.data.shape[0])\n np.random.shuffle(indices)\n self.q = list(indices)","def shuffle(self):\n new_nums = self.nums[:]\n n = len(new_nums)\n import random\n for i in range(n):\n rand_num = random.randint(0, n - 1)\n # Swap nums[i] with nums[randint]\n temp = new_nums[i]\n new_nums[i] = new_nums[rand_num]\n new_nums[rand_num] = temp\n return new_nums","def changeState(self, xyPoints):\n nPts = len(xyPoints)\n ind0 = random.randint(1, nPts-1)\n ind1 = random.randint(1, nPts-1)\n while ind1 == ind0:\n ind1 = random.randint(1, nPts-1)\n # make copy of the sources to make sure the swap works correctly\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])","def shuffle(self) -> NoReturn:\n for edge_type in self.edge_types:\n for edge_class in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][edge_class] = np.random.permutation(\n self.train_edges[edge_type][edge_class])\n\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\n for edge_type, edge_class in self.edge_types.items()}\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\n self.edge_types.items()}\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\n self.iter = 0","def shuffle(self, seed=0):\n if isinstance(seed, numbers.Integral): # also allow for np.int8(n) and the like\n if seed != -1:\n if seed == 0:\n random.seed()\n else:\n random.seed(seed)\n random.shuffle(self.idxs)\n else: # not an integer seed: None or some other type\n # same as seed 0\n random.seed()\n random.shuffle(self.idxs)","def trainSet(self):\r\n self.currIdx = 0\r\n random.shuffle(self.trainSamples)\r\n self.samples = self.trainSamples[:self.numTrainSamplesPerEpoch]","def __shuffle_cards(self):\n random.shuffle(self.cards)","def shuffle(self):\n x = len(self.org)\n result = self.org[:]\n var = x\n for i in range(x):\n id = random.randrange(0, var)\n result[id], result[var - 1] = result[var - 1], result[id]\n var -= 1\n\n return result","def _shuffle(inputs):\n\texpand_inputs = tf.stack(inputs, axis = -1)\n\tshuffled_inputs = tf.random_shuffle(expand_inputs)\n\treturn tf.unstack(shuffled_inputs)","def shuffle(arr):\n for i in range(len(arr)):\n j = int(math.floor(random.random() * len(arr)))\n arr[i], arr[j] = arr[j], arr[i]","def shuffle(self):\n random.shuffle(self.deckcards)","def sort_random(i):\n return np.random.rand()","def shuffle_data(data):\n idx = np.arange(len(data))\n np.random.shuffle(idx)\n return data[idx, ...]","def shuffle(self): \n for x in range(12):\n self.right(primary=-60, counter=0)\n time.sleep(.1)\n self.left(primary=-60, counter=0)\n time.sleep(.1)\n self.stop()","def next_batch(self, batch_size, shuffle=True):","def shuffle(data):\n\n shuffle = np.arange(data.shape[0])\n np.random.shuffle(shuffle)\n undo_shuffle = np.argsort(shuffle)\n\n return (data[shuffle], undo_shuffle)","def shuffle(self) -> List[int]:\n for i in range(len(self.nums) - 1, 0, -1):\n pivot = random.randint(0, i) # 前闭后闭\n self.nums[i], self.nums[pivot] = self.nums[pivot], self.nums[i]\n return self.nums","def on_epoch_end(self):\r\n self.indexes = np.arange(len(self.list_IDs))\r\n if self.shuffle == True:\r\n np.random.shuffle(self.indexes)","def shuffle(self):\n import random\n random.shuffle(self.cards)","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def on_epoch_end(self):\n self.indexes = np.arange(len(self.list_IDs))\n if self.shuffle == True:\n np.random.shuffle(self.indexes)","def on_epoch_end(self):\n self.indexes = np.arange(len(self.list_IDs))\n if self.shuffle == True:\n np.random.shuffle(self.indexes)","def get_shuffle_ids(self, bsz):\n forward_inds = torch.randperm(bsz).long().cuda()\n backward_inds = torch.zeros(bsz).long().cuda()\n value = torch.arange(bsz).long().cuda()\n backward_inds.index_copy_(0, forward_inds, value)\n return forward_inds, backward_inds","def reshuffle(self):\n place = 0\n saveplace = 0\n\n \"\"\" Now we're going to randomly swap cards to the bottom of the deck until we reach the top \"\"\"\n for counter in reversed(range(self.currentCard + 1, self.deckSize)):\n \n place = self.randomMethod() * (counter + 1 - self.currentCard)\n place = math.floor(place) + self.currentCard\n saveplace = self.shuffledPtrs[counter]\n self.shuffledPtrs[counter] = self.shuffledPtrs[place]\n self.shuffledPtrs[place] = saveplace","def calc_granger_shuffle(self):\n if not hasattr(self, 'input_data'):\n self.preprocess_and_check_stationarity()\n temp_series = [np.stack([np.random.permutation(x)\n for x in self.input_data.T]).T\n for i in trange(self.n_shuffles)]\n\n outs_temp = parallelize(self.calc_granger, temp_series, n_jobs=30)\n outs_temp = [x[0] for x in outs_temp]\n self.shuffle_outs = np.array(outs_temp)","def shuffle_pair(x,y):\n xy = list(zip(x,y))\n np.random.shuffle(xy)\n x, y = zip(*xy)\n x = np.array(x)\n y = np.array(y)","def shuffle_pos(self, ):\n x, y = 0, 0\n while self.maze.structure[int(y / 40)][int(x / 40)] != \"0\" \\\n or (x, y) in self.forbiden_tulpes:\n x = random.randint(0, 14) * sprite_size\n y = random.randint(0, 14) * sprite_size\n self.forbiden_tulpes.append((x, y))\n return x, y","def shuffle(self):\n self.turn_by_deg(20)\n time.sleep(.25)\n self.fwd()\n time.sleep(1)\n self.stop()\n self.back()\n time.sleep(1)\n self.stop()\n self.turn_by_deg(-40)\n time.sleep(.25)\n self.fwd()\n time.sleep(1)\n self.back()\n time.sleep(1)\n self.stop()"],"string":"[\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def _shuffle_roidb_idx(self):\\n self.perm = np.random.permutation(np.arange(self.num_images))\\n self.cur = 0\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def shuffle(self, idx=None):\\n for i in [idx] if idx is not None else range(self.num_buckets):\\n self.buckets[i] = self.buckets[i].sample(frac=1).reset_index(drop=True)\\n self.cursor[i] = 0\",\n \"def _batch_shuffle_ddp(self, x):\\n # gather from all gpus\\n batch_size_this = x.shape[0]\\n x_gather = concat_all_gather(x)\\n batch_size_all = x_gather.shape[0]\\n\\n num_gpus = batch_size_all // batch_size_this\\n\\n # random shuffle index\\n idx_shuffle = torch.randperm(batch_size_all).cuda()\\n\\n # broadcast to all gpus\\n torch.distributed.broadcast(idx_shuffle, src=0)\\n\\n # index for restoring\\n idx_unshuffle = torch.argsort(idx_shuffle)\\n\\n # shuffled index for this gpu\\n gpu_idx = torch.distributed.get_rank()\\n idx_this = idx_shuffle.view(num_gpus, -1)[gpu_idx]\\n\\n return x_gather[idx_this], idx_unshuffle\",\n \"def shuffle(self):\\n self.train_nodes = np.random.permutation(self.train_nodes)\\n self.batch_num = 0\",\n \"def shuffle(self):\\n self.train_nodes = np.random.permutation(self.train_nodes)\\n self.batch_num = 0\",\n \"def _shuffle(self, reinit_indexes = False):\\n print('Shuffling data...')\\n # set seed for reproducibility\\n #random.seed()\\n # shuffle identities\\n random.shuffle(self.identities)\\n # shuffle images associated to each identity\\n for identity in self.groundtruth_metadata.keys():\\n random.shuffle(self.groundtruth_metadata[identity]['metadata'])\\n if reinit_indexes:\\n self.groundtruth_metadata[identity]['index'] = 0\\n print('Finished shuffling data!')\",\n \"def shuffle(self):\\n self.train_edges = np.random.permutation(self.train_edges)\\n self.nodes = np.random.permutation(self.nodes)\\n self.batch_num = 0\",\n \"def shuffle(self):\\n self.edges = np.random.permutation(self.edges)\\n self.batch_num = 0\",\n \"def shuffle_data(self):\\n images = list(self.train_images)\\n labels = list(self.train_labels)\\n self.train_images = []\\n self.train_labels = []\\n\\n # create list of permutated index and shuffle data accoding to list\\n idx = np.random.permutation(len(labels))\\n for i in idx:\\n self.train_images.append(images[i])\\n self.train_labels.append(labels[i])\",\n \"def _shuffle(self, r, idx_to_shuffle = None):\\n n_features = r.shape[0]\\n n_trials = r.shape[1]\\n r_sh = r\\n if idx_to_shuffle is None:\\n idx_to_shuffle = range(n_features)\\n for i in range(n_features):\\n if i in idx_to_shuffle:\\n r_sh[i,:] = r[i,random.permutation(range(n_trials))]\\n return r_sh\",\n \"def shuffle_T(self):\\n np.random.shuffle(self.T)\",\n \"def next_batch_shuffle(self, batch_size):\\n\\tperm0 = np.arange(self.TRAIN_SIZE)\\n np.random.shuffle(perm0)\\n self.data['x_train'], self.data['y_train'] = self.data['x_train'][perm0,:], self.data['y_train'][perm0,:]\\n\\treturn self.data['x_train'][:batch_size], self.data['y_train'][:batch_size]\",\n \"def shuffle(self):\\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\\n perm = np.random.permutation(self.X_data.shape[0])\\n for old_idx, new_idx in enumerate(perm):\\n new_X[new_idx] = self.X_data[old_idx]\\n new_Y[new_idx] = self.Y_data[old_idx]\\n self.X_data = new_X\\n self.Y_data = new_Y\",\n \"def shuffle(self):\\n\\t\\t\\trandom.seed(231)\\n\\t\\t\\trandom.shuffle(self.Ind)\\n\\t\\t\\tself.Ind = self.Ind[:int(len(self.Ind)/5)*5].reshape((self.cv_iters, -1))\\n\\t\\t\\t#index of valication set\\n\\t\\t\\tself.CVindex = 1\\n\\t\\t\\tself.Testindex = 0\",\n \"def shuffle_train(self):\\r\\n if self.data_container.task == 'Classify':\\r\\n id_train_list=[]\\r\\n for i in self.idx_train_list:\\r\\n id_train_list.append(self._random_state.choice(i,self.train_parms[0]))\\r\\n for j in self._random_state.choice(self.unique_value, self.train_parms[1]):\\r\\n id_train_list.append(self._random_state.choice(self.idx_train_list[j],1))\\r\\n self.idx['train'] = np.concatenate(id_train_list, axis=0)\\r\\n \\r\\n self.idx['train'] = self._random_state.permutation(self.idx['train'])\",\n \"def shuffle(self):\\n for edge_type in self.edge_types:\\n for k in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\\n self.current_edge_type_idx = 0\\n self.freebatch_edge_types = list(range(self.num_edge_types))\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\\n self.iter = 0\",\n \"def shuffle(self):\\n order = np.arange(len(self.data))\\n np.random.seed(0xA5EED)\\n np.random.shuffle(order)\\n self.data = self.data.iloc[order]\\n return order\",\n \"def shuffle(self):\\n self.x['train'], self.y['train'] = self._shuffle(\\n self.x['train'],\\n self.y['train']\\n )\",\n \"def shuffle(self, random_state=None): \\n if random_state is None:\\n random_state = self.random_state\\n perm_ids = random_state.permutation(self.n_examples)\\n self.u = self.u[perm_ids]\\n self.v = self.v[perm_ids]\\n self.rating = self.rating[perm_ids]\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.indexes = np.random.permutation(self.indexes)\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.indexes = np.random.permutation(self.indexes)\",\n \"def shuffle(self):\\n perm = self.rng.permutation(self.inputs.shape[0])\\n self._current_order = self._current_order[perm]\\n self.inputs = self.inputs[perm]\\n self.targets = self.targets[perm]\",\n \"def _batch_shuffle_single_gpu(self, x):\\n # random shuffle index\\n idx_shuffle = torch.randperm(x.shape[0]).cuda()\\n\\n # index for restoring\\n idx_unshuffle = torch.argsort(idx_shuffle)\\n\\n return x[idx_shuffle], idx_unshuffle\",\n \"def shuffle(self):\\n perm = self.rng.permutation(self.inputs.shape[0])\\n self._current_order = self._current_order[perm]\\n self.inputs = self.inputs[perm]\\n self.targets = self.targets[perm]\\n self.target_ids = self.target_ids[perm]\",\n \"def post_randomize(self):\\n super(BatchRandomizer, self).post_randomize()\\n self.batch_idx += 1\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n np.random.shuffle(self.indices)\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n np.random.shuffle(self.indexes)\",\n \"def _shuffle_roidb_inds(self):\\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\\n self._cur = 0\",\n \"def shuffle(self):\\n for i in range(10):\\n random.shuffle(self.set)\",\n \"def on_epoch_end(self):\\n if self.is_train:\\n np.random.shuffle(self.image_indexes)\",\n \"def shuffle(self):\\n self.np_random.shuffle(self.deck)\",\n \"def on_epoch_end(self):\\n if self.shuffle == True:\\n numpy.random.shuffle(self.indexes)\",\n \"def _batch_unshuffle_ddp(self, x, idx_unshuffle):\\n # gather from all gpus\\n batch_size_this = x.shape[0]\\n x_gather = concat_all_gather(x)\\n batch_size_all = x_gather.shape[0]\\n\\n num_gpus = batch_size_all // batch_size_this\\n\\n # restored index for this gpu\\n gpu_idx = torch.distributed.get_rank()\\n idx_this = idx_unshuffle.view(num_gpus, -1)[gpu_idx]\\n\\n return x_gather[idx_this]\",\n \"def shuffle_dataset(self, seed=None):\\n stacked = np.r_[self.X_train,\\n self.y_train]\\n shuffle(stacked.T)\\n X_shuffled = stacked[:self.nfeatures,:]\\n y_shuffled = stacked[self.nfeatures:,:]\\n return X_shuffled, y_shuffled\",\n \"def shuffle(self):\\n reorder(self.cards) #importing shuffle as reorder\",\n \"def _compute_indices(self):\\n self.indices = np.arange(len(self.im_filenames))\\n np.random.shuffle(self.indices)\",\n \"def order_batch(store_name, x=4):\\n for i in range(x):\\n random_order(store_name)\",\n \"def batch_shuffle(index_array, batch_size):\\n batch_count = int(len(index_array) / batch_size)\\n # to reshape we need to be cleanly divisible by batch size\\n # we stash extra items and reappend them after shuffling\\n last_batch = index_array[batch_count * batch_size:]\\n index_array = index_array[:batch_count * batch_size]\\n index_array = index_array.reshape((batch_count, batch_size))\\n np.random.shuffle(index_array)\\n index_array = index_array.flatten()\\n return np.append(index_array, last_batch)\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n p = np.random.permutation(len(self.X))\\n self.X = self.X[p]\\n self.y = self.y[p]\",\n \"def shuffle(self):\\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\\n if self.schema != 'default':\\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\\n\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, \\\\\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\\\\n self.neg_paths_shuffled, \\\\\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths,\\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\\n self.neg_paths_sampled,\\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\\n self.pos_paths_words, self.neg_paths_words_sampled)\\n else:\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)\",\n \"def shuffle(self):\\n self.__c_elem().melange()\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.indices = np.random.permutation(self._len)\",\n \"def shuffle(self):\\n self.shuffle_range(len(self.cards))\",\n \"def _shuffle_roidb_inds(self):\\n ## 设置cur来指向现在访问的长度\\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\\n self._cur = 0\",\n \"def get_next_batch(self):\\n if self.index_in_epoch + self.batch_size > self.X.shape[0]:\\n idx = np.arange(0, self.X.shape[0])\\n self.index_in_epoch = 0\\n np.random.shuffle(idx)\\n self.X = self.X[idx]\\n self.y = self.y[idx]\\n # idx = idx[self.index_in_epoch:self.index_in_epoch + self.batch_size]\\n # data_shuffle = [self.X[i] for i in idx]\\n # labels_shuffle = [self.y[i] for i in idx]\\n # data_shuffle = np.asarray(data_shuffle)\\n # data_shuffle = np.reshape(data_shuffle, newshape=(self.batch_size, 1024))\\n #\\n # labels_shuffle = np.asarray(labels_shuffle)\\n # labels_shuffle = np.reshape(labels_shuffle, newshape=(self.batch_size, 26))\\n data_shuffle = self.X[self.index_in_epoch:self.index_in_epoch + self.batch_size, :]\\n data_shuffle = np.reshape(data_shuffle, newshape=(self.batch_size, 32, 32, 1))\\n labels_shuffle = self.y[self.index_in_epoch:self.index_in_epoch + self.batch_size, :]\\n labels_shuffle = np.reshape(labels_shuffle, newshape=(self.batch_size, 26))\\n self.index_in_epoch += self.batch_size\\n return data_shuffle, labels_shuffle\",\n \"def _shuffle():\\n\\n random.shuffle(deck)\",\n \"def shuffle(self):\\n index = list(range(self.k))\\n random.shuffle(index)\\n for i, j in enumerate(index):\\n self.list[i] = self.dic[j]\\n return self.list\",\n \"def _shuffle_roidb_inds(self):\\r\\n if True: #cfg.TRAIN.ASPECT_GROUPING:\\r\\n widths = np.array([r['width'] for r in self._roidb])\\r\\n heights = np.array([r['height'] for r in self._roidb])\\r\\n horz = (widths >= heights)\\r\\n vert = np.logical_not(horz)\\r\\n horz_inds = np.where(horz)[0]\\r\\n vert_inds = np.where(vert)[0]\\r\\n\\r\\n horz_inds = np.random.permutation(horz_inds)\\r\\n vert_inds = np.random.permutation(vert_inds)\\r\\n mb = 2 #cfg.TRAIN.IMS_PER_BATCH\\r\\n horz_inds = horz_inds[:(len(horz_inds) // mb) * mb]\\r\\n vert_inds = vert_inds[:(len(vert_inds) // mb) * mb]\\r\\n inds = np.hstack((horz_inds, vert_inds))\\r\\n\\r\\n inds = np.reshape(inds, (-1, mb))\\r\\n row_perm = np.random.permutation(np.arange(inds.shape[0]))\\r\\n inds = np.reshape(inds[row_perm, :], (-1, ))\\r\\n self._perm = inds\\r\\n else:\\r\\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\\r\\n self._perm = deque(self._perm)\\r\\n self._cur = 0\",\n \"def shuffle(self):\\r\\n self._current = 0\\r\\n random.shuffle(self._cards)\",\n \"def shuffle(self):\\n self.logger.debug('Shuffling wallpaper queue')\\n\\n random.shuffle(self.wallpapers)\\n self.index = 0\",\n \"def shuffle(self):\\n for i in xrange(self.n - 1):\\n pos = random.randint(i, self.n - 1)\\n self.to[i], self.to[pos] = self.to[pos], self.to[i]\\n self.a[i], self.a[pos] = self.a[pos], self.a[i]\\n return self.a\",\n \"def shuffle(self):\\r\\n random.shuffle(self.deck)\",\n \"def shuffle(self) -> List[int]:\\n for i in range(len(self.array)):\\n tmp_idx = randrange(i, len(self.array))\\n self.array[i], self.array[tmp_idx] = self.array[tmp_idx], self.array[i]\\n return self.array\",\n \"def shuffle(self):\\r\\n #\\r\\n shuffled_seed = copy.deepcopy(self)\\r\\n #\\r\\n # for each location [x0][y0], randomly choose another location\\r\\n # [x1][y1] and swap the values of the cells in the two locations.\\r\\n #\\r\\n for x0 in range(self.xspan):\\r\\n for y0 in range(self.yspan):\\r\\n x1 = rand.randrange(self.xspan)\\r\\n y1 = rand.randrange(self.yspan)\\r\\n temp = shuffled_seed.cells[x0][y0]\\r\\n shuffled_seed.cells[x0][y0] = shuffled_seed.cells[x1][y1]\\r\\n shuffled_seed.cells[x1][y1] = temp\\r\\n #\\r\\n return shuffled_seed\",\n \"def Shuffle(self):\\r\\n random.shuffle(self.cards_list)\",\n \"def generate_shuffle(self):\\n self._shuffle_list = range(len(self._playlist))\\n random.shuffle(self._shuffle_list)\\n if self._active_index in self._shuffle_list:\\n self._shuffle_list.remove(self._active_index)\",\n \"def shuffle_priors(self):\\n\\n if self.shuffle_prior_axis is None:\\n return None\\n elif self.shuffle_prior_axis == 0:\\n # Shuffle index (genes) in the priors_data\\n utils.Debug.vprint(\\\"Randomly shuffling prior [{sh}] gene data\\\".format(sh=self.priors_data.shape))\\n prior_index = self.priors_data.index.tolist()\\n self.priors_data = self.priors_data.sample(frac=1, axis=0, random_state=self.random_seed)\\n self.priors_data.index = prior_index\\n elif self.shuffle_prior_axis == 1:\\n # Shuffle columns (TFs) in the priors_data\\n utils.Debug.vprint(\\\"Randomly shuffling prior [{sh}] TF data\\\".format(sh=self.priors_data.shape))\\n prior_index = self.priors_data.columns.tolist()\\n self.priors_data = self.priors_data.sample(frac=1, axis=1, random_state=self.random_seed)\\n self.priors_data.columns = prior_index\\n else:\\n raise ValueError(\\\"shuffle_prior_axis must be 0 or 1\\\")\",\n \"def point_random_position(self, point_distribution, mask):\\n batch_size = point_distribution.size(0)\\n mask_np = to_np(mask) # batch x time\\n indices = []\\n for i in range(batch_size):\\n msk = mask_np[i] # time\\n indices.append(np.random.choice(len(msk), 2, p=msk / np.sum(msk, -1)))\\n indices = to_pt(np.stack(indices, 0), self.use_cuda) # batch x 2\\n return indices\",\n \"def shuffle(self):\\n random.shuffle(self.get_cards())\",\n \"def __getitem__(self, idx):\\n index = lambda x: x[idx * self.batch_size:(idx + 1) * self.batch_size]\\n batch_questions = index(self.questions_shuffled) # Shape (batch, seqlen)\\n batch_questions_dep = index(self.questions_dep_shuffled) #Shape (batch, seqlen)\\n batch_questions_dep_mask = index(self.questions_dep_mask_shuffled) #Shape (batch, seqlen)\\n batch_pos_paths = index(self.pos_paths_shuffled) # Shape (batch, seqlen)\\n batch_pos_paths_words = index(self.pos_paths_words_shuffled) # Shape (batch, seqlen)\\n batch_neg_paths = index(self.neg_paths_shuffled) # Shape (batch, seqlen)\\n batch_neg_paths_words = index(self.neg_paths_words_shuffled) # Shape (batch, seqlen)\\n if self.schema != 'default':\\n batch_neg_paths_rel1 = index(self.neg_paths_rel1_shuffled) # Shape (batch, seqlen)\\n batch_neg_paths_rel2 = index(self.neg_paths_rel2_shuffled) # Shape (batch, seqlen)\\n batch_neg_paths_rel3 = index(self.neg_paths_rel3_shuffled) # Shape (batch, seqlen)\\n batch_neg_paths_rel4 = index(self.neg_paths_rel4_shuffled) # Shape (batch, seqlen)\\n batch_pos_paths_rel1 = index(self.pos_paths_rel1_shuffled) # Shape (batch, seqlen)\\n batch_pos_paths_rel2 = index(self.pos_paths_rel2_shuffled) # Shape (batch, seqlen)\\n batch_pos_paths_rel3 = index(self.pos_paths_rel3_shuffled) # Shape (batch, seqlen)\\n batch_pos_paths_rel4 = index(self.pos_paths_rel4_shuffled) # Shape (batch, seqlen)\\n\\n if self.schema == 'default':\\n return ([batch_questions, batch_questions_dep, batch_questions_dep_mask,\\n batch_pos_paths, batch_neg_paths,\\n batch_pos_paths_words,batch_neg_paths_words], self.dummy_y)\\n else:\\n return ([batch_questions, batch_questions_dep, batch_questions_dep_mask,\\n batch_pos_paths,\\n batch_pos_paths_rel1,batch_pos_paths_rel2,batch_pos_paths_rel3,batch_pos_paths_rel4,\\n batch_neg_paths,\\n batch_neg_paths_rel1,batch_neg_paths_rel2,batch_neg_paths_rel3,batch_neg_paths_rel4,\\n batch_pos_paths_words,batch_neg_paths_words], self.dummy_y)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self) -> List[int]:\",\n \"def _random_permutation(self):\\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))\",\n \"def shuffle(self):\\n shuffle(self.cards)\",\n \"def shuffle(self):\\n shuffle(self.cards)\",\n \"def __new_epoch(self):\\n self.epoch += 1\\n indices = np.arange(self.data.shape[0])\\n np.random.shuffle(indices)\\n self.q = list(indices)\",\n \"def shuffle(self):\\n new_nums = self.nums[:]\\n n = len(new_nums)\\n import random\\n for i in range(n):\\n rand_num = random.randint(0, n - 1)\\n # Swap nums[i] with nums[randint]\\n temp = new_nums[i]\\n new_nums[i] = new_nums[rand_num]\\n new_nums[rand_num] = temp\\n return new_nums\",\n \"def changeState(self, xyPoints):\\n nPts = len(xyPoints)\\n ind0 = random.randint(1, nPts-1)\\n ind1 = random.randint(1, nPts-1)\\n while ind1 == ind0:\\n ind1 = random.randint(1, nPts-1)\\n # make copy of the sources to make sure the swap works correctly\\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])\",\n \"def shuffle(self) -> NoReturn:\\n for edge_type in self.edge_types:\\n for edge_class in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][edge_class] = np.random.permutation(\\n self.train_edges[edge_type][edge_class])\\n\\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\\n for edge_type, edge_class in self.edge_types.items()}\\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\\n self.edge_types.items()}\\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\\n self.iter = 0\",\n \"def shuffle(self, seed=0):\\n if isinstance(seed, numbers.Integral): # also allow for np.int8(n) and the like\\n if seed != -1:\\n if seed == 0:\\n random.seed()\\n else:\\n random.seed(seed)\\n random.shuffle(self.idxs)\\n else: # not an integer seed: None or some other type\\n # same as seed 0\\n random.seed()\\n random.shuffle(self.idxs)\",\n \"def trainSet(self):\\r\\n self.currIdx = 0\\r\\n random.shuffle(self.trainSamples)\\r\\n self.samples = self.trainSamples[:self.numTrainSamplesPerEpoch]\",\n \"def __shuffle_cards(self):\\n random.shuffle(self.cards)\",\n \"def shuffle(self):\\n x = len(self.org)\\n result = self.org[:]\\n var = x\\n for i in range(x):\\n id = random.randrange(0, var)\\n result[id], result[var - 1] = result[var - 1], result[id]\\n var -= 1\\n\\n return result\",\n \"def _shuffle(inputs):\\n\\texpand_inputs = tf.stack(inputs, axis = -1)\\n\\tshuffled_inputs = tf.random_shuffle(expand_inputs)\\n\\treturn tf.unstack(shuffled_inputs)\",\n \"def shuffle(arr):\\n for i in range(len(arr)):\\n j = int(math.floor(random.random() * len(arr)))\\n arr[i], arr[j] = arr[j], arr[i]\",\n \"def shuffle(self):\\n random.shuffle(self.deckcards)\",\n \"def sort_random(i):\\n return np.random.rand()\",\n \"def shuffle_data(data):\\n idx = np.arange(len(data))\\n np.random.shuffle(idx)\\n return data[idx, ...]\",\n \"def shuffle(self): \\n for x in range(12):\\n self.right(primary=-60, counter=0)\\n time.sleep(.1)\\n self.left(primary=-60, counter=0)\\n time.sleep(.1)\\n self.stop()\",\n \"def next_batch(self, batch_size, shuffle=True):\",\n \"def shuffle(data):\\n\\n shuffle = np.arange(data.shape[0])\\n np.random.shuffle(shuffle)\\n undo_shuffle = np.argsort(shuffle)\\n\\n return (data[shuffle], undo_shuffle)\",\n \"def shuffle(self) -> List[int]:\\n for i in range(len(self.nums) - 1, 0, -1):\\n pivot = random.randint(0, i) # 前闭后闭\\n self.nums[i], self.nums[pivot] = self.nums[pivot], self.nums[i]\\n return self.nums\",\n \"def on_epoch_end(self):\\r\\n self.indexes = np.arange(len(self.list_IDs))\\r\\n if self.shuffle == True:\\r\\n np.random.shuffle(self.indexes)\",\n \"def shuffle(self):\\n import random\\n random.shuffle(self.cards)\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def on_epoch_end(self):\\n self.indexes = np.arange(len(self.list_IDs))\\n if self.shuffle == True:\\n np.random.shuffle(self.indexes)\",\n \"def on_epoch_end(self):\\n self.indexes = np.arange(len(self.list_IDs))\\n if self.shuffle == True:\\n np.random.shuffle(self.indexes)\",\n \"def get_shuffle_ids(self, bsz):\\n forward_inds = torch.randperm(bsz).long().cuda()\\n backward_inds = torch.zeros(bsz).long().cuda()\\n value = torch.arange(bsz).long().cuda()\\n backward_inds.index_copy_(0, forward_inds, value)\\n return forward_inds, backward_inds\",\n \"def reshuffle(self):\\n place = 0\\n saveplace = 0\\n\\n \\\"\\\"\\\" Now we're going to randomly swap cards to the bottom of the deck until we reach the top \\\"\\\"\\\"\\n for counter in reversed(range(self.currentCard + 1, self.deckSize)):\\n \\n place = self.randomMethod() * (counter + 1 - self.currentCard)\\n place = math.floor(place) + self.currentCard\\n saveplace = self.shuffledPtrs[counter]\\n self.shuffledPtrs[counter] = self.shuffledPtrs[place]\\n self.shuffledPtrs[place] = saveplace\",\n \"def calc_granger_shuffle(self):\\n if not hasattr(self, 'input_data'):\\n self.preprocess_and_check_stationarity()\\n temp_series = [np.stack([np.random.permutation(x)\\n for x in self.input_data.T]).T\\n for i in trange(self.n_shuffles)]\\n\\n outs_temp = parallelize(self.calc_granger, temp_series, n_jobs=30)\\n outs_temp = [x[0] for x in outs_temp]\\n self.shuffle_outs = np.array(outs_temp)\",\n \"def shuffle_pair(x,y):\\n xy = list(zip(x,y))\\n np.random.shuffle(xy)\\n x, y = zip(*xy)\\n x = np.array(x)\\n y = np.array(y)\",\n \"def shuffle_pos(self, ):\\n x, y = 0, 0\\n while self.maze.structure[int(y / 40)][int(x / 40)] != \\\"0\\\" \\\\\\n or (x, y) in self.forbiden_tulpes:\\n x = random.randint(0, 14) * sprite_size\\n y = random.randint(0, 14) * sprite_size\\n self.forbiden_tulpes.append((x, y))\\n return x, y\",\n \"def shuffle(self):\\n self.turn_by_deg(20)\\n time.sleep(.25)\\n self.fwd()\\n time.sleep(1)\\n self.stop()\\n self.back()\\n time.sleep(1)\\n self.stop()\\n self.turn_by_deg(-40)\\n time.sleep(.25)\\n self.fwd()\\n time.sleep(1)\\n self.back()\\n time.sleep(1)\\n self.stop()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72801876","0.72373664","0.6753397","0.6724248","0.65495604","0.6484776","0.6474384","0.6474384","0.6457585","0.64205366","0.6403728","0.6389177","0.63853645","0.6350583","0.6297481","0.62960184","0.62893575","0.62821025","0.6237439","0.62186027","0.6217808","0.61386067","0.61190194","0.61190194","0.61083096","0.6106143","0.6104674","0.6084777","0.60418606","0.6036556","0.6033777","0.60334295","0.6019191","0.6002195","0.5898839","0.5853808","0.5830969","0.582919","0.58107936","0.5784427","0.57702607","0.5764139","0.5763664","0.57517445","0.5751735","0.57176733","0.5696302","0.56918114","0.5665166","0.56436896","0.56302196","0.56253093","0.56239337","0.56194913","0.5619279","0.5616702","0.5610648","0.56079763","0.5605751","0.5595525","0.55864936","0.5584802","0.5582682","0.5571384","0.5571384","0.5571384","0.5571384","0.5571384","0.55668133","0.55631346","0.55446726","0.55446726","0.5539016","0.553792","0.5537102","0.5536335","0.55361885","0.5532427","0.55311567","0.5516761","0.55121404","0.550307","0.5485027","0.548377","0.5476915","0.54670316","0.5466476","0.5461254","0.5437888","0.54362357","0.54360837","0.5432528","0.54262584","0.54262584","0.5423559","0.5407527","0.54010415","0.54005796","0.53842086","0.53838027"],"string":"[\n \"0.72801876\",\n \"0.72373664\",\n \"0.6753397\",\n \"0.6724248\",\n \"0.65495604\",\n \"0.6484776\",\n \"0.6474384\",\n \"0.6474384\",\n \"0.6457585\",\n \"0.64205366\",\n \"0.6403728\",\n \"0.6389177\",\n \"0.63853645\",\n \"0.6350583\",\n \"0.6297481\",\n \"0.62960184\",\n \"0.62893575\",\n \"0.62821025\",\n \"0.6237439\",\n \"0.62186027\",\n \"0.6217808\",\n \"0.61386067\",\n \"0.61190194\",\n \"0.61190194\",\n \"0.61083096\",\n \"0.6106143\",\n \"0.6104674\",\n \"0.6084777\",\n \"0.60418606\",\n \"0.6036556\",\n \"0.6033777\",\n \"0.60334295\",\n \"0.6019191\",\n \"0.6002195\",\n \"0.5898839\",\n \"0.5853808\",\n \"0.5830969\",\n \"0.582919\",\n \"0.58107936\",\n \"0.5784427\",\n \"0.57702607\",\n \"0.5764139\",\n \"0.5763664\",\n \"0.57517445\",\n \"0.5751735\",\n \"0.57176733\",\n \"0.5696302\",\n \"0.56918114\",\n \"0.5665166\",\n \"0.56436896\",\n \"0.56302196\",\n \"0.56253093\",\n \"0.56239337\",\n \"0.56194913\",\n \"0.5619279\",\n \"0.5616702\",\n \"0.5610648\",\n \"0.56079763\",\n \"0.5605751\",\n \"0.5595525\",\n \"0.55864936\",\n \"0.5584802\",\n \"0.5582682\",\n \"0.5571384\",\n \"0.5571384\",\n \"0.5571384\",\n \"0.5571384\",\n \"0.5571384\",\n \"0.55668133\",\n \"0.55631346\",\n \"0.55446726\",\n \"0.55446726\",\n \"0.5539016\",\n \"0.553792\",\n \"0.5537102\",\n \"0.5536335\",\n \"0.55361885\",\n \"0.5532427\",\n \"0.55311567\",\n \"0.5516761\",\n \"0.55121404\",\n \"0.550307\",\n \"0.5485027\",\n \"0.548377\",\n \"0.5476915\",\n \"0.54670316\",\n \"0.5466476\",\n \"0.5461254\",\n \"0.5437888\",\n \"0.54362357\",\n \"0.54360837\",\n \"0.5432528\",\n \"0.54262584\",\n \"0.54262584\",\n \"0.5423559\",\n \"0.5407527\",\n \"0.54010415\",\n \"0.54005796\",\n \"0.53842086\",\n \"0.53838027\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.725899"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":9463,"cells":{"query":{"kind":"string","value":"Randomly rotate the point clouds to augument the dataset rotation is per shape based along up direction"},"document":{"kind":"string","value":"def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data"},"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 rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def random_rotate(self):\r\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\r\n flip = rand.randrange(0, 2, 1) # 0, 1\r\n new_seed = copy.deepcopy(self)\r\n # rotate by 90 degrees * rotation (0, 90, 180 270)\r\n new_seed.cells = np.rot90(new_seed.cells, rotation) \r\n if (flip == 1):\r\n # flip upside down\r\n new_seed.cells = np.flipud(new_seed.cells)\r\n new_seed.xspan = new_seed.cells.shape[0]\r\n new_seed.yspan = new_seed.cells.shape[1]\r\n return new_seed","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k,:,0:3]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def RotatePointCloud(batch_data):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1],])\n return np.dot(batch_data, rotation_matrix)","def rotate_point_cloud_in_plane(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, -sinval, 0],\n [sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\n ## https://en.wikipedia.org/wiki/Rotation_matrix\n if(use_rotation_tensor != True):\n angle_range = DEGREES\n x_angle = radians(random.random() * angle_range)\n y_angle = radians(random.random() * angle_range)\n z_angle = radians(random.random() * angle_range)\n\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\n rotation_matrix = torch.mm(rot_y, rot_z)\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \n\n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n \n \n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\n self.rotation_matrix = rotation_matrix\n \n if(save_rotation_tensor):\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\n else: \n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\n return pointcloud_model_rotated[:,:,0:3]","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n # rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]]) # rotate along y axis\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data, batch_label):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\n return rotated_data, rotated_label","def randomize_trajectory(self):\n self.angle = randint(-360, 360)\n self.speed = randint(1, 5)/2.5","def random_rotation(self, img, p = 0.5):\n if self.decision(p):\n theta = random.randrange(-15, 15)\n phi = random.randrange(-15, 15)\n gamma = random.randrange(-15, 15)\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\n # check if cut is ahve to much dark pixels, more then 20 %\n non_zeros = np.count_nonzero(roi)\n non_zeros_procent = non_zeros / roi.size\n if non_zeros_procent < 0.8:\n pass\n else:\n img = roi\n return img","def _get_random_transform(self, img_shape, seed=None):\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if self.rotation_range:\n theta = np.random.uniform(\n -self.rotation_range,\n self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n try: # 1-D array-like or int\n tx = np.random.choice(self.height_shift_range)\n tx *= np.random.choice([-1, 1])\n except ValueError: # floating point\n tx = np.random.uniform(-self.height_shift_range,\n self.height_shift_range)\n if np.max(self.height_shift_range) < 1:\n tx *= img_shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n try: # 1-D array-like or int\n ty = np.random.choice(self.width_shift_range)\n ty *= np.random.choice([-1, 1])\n except ValueError: # floating point\n ty = np.random.uniform(-self.width_shift_range,\n self.width_shift_range)\n if np.max(self.width_shift_range) < 1:\n ty *= img_shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(\n -self.shear_range,\n self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(\n self.zoom_range[0],\n self.zoom_range[1],\n 2)\n\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\n\n channel_shift_intensity = None\n if self.channel_shift_range != 0:\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\n self.channel_shift_range)\n\n brightness = None\n if self.brightness_range is not None:\n brightness = np.random.uniform(self.brightness_range[0],\n self.brightness_range[1])\n\n transform_parameters = {'theta': theta,\n 'tx': tx,\n 'ty': ty,\n 'shear': shear,\n 'zx': zx,\n 'zy': zy,\n 'flip_horizontal': flip_horizontal,\n 'flip_vertical': flip_vertical,\n 'channel_shift_intensity': channel_shift_intensity,\n 'brightness': brightness}\n\n return transform_parameters","def random_rotation(image, gt, normal=False, random_state=None):\n if random_state is None:\n random_state = np.random.RandomState(None)\n\n degree = int(random_state.normal(0, 10)) if normal else random_state.randint(-10, 10)\n rows, cols = image.shape[:2]\n\n mat = cv2.getRotationMatrix2D((cols / 2, rows / 2), degree, 1)\n result_im = cv2.warpAffine(image, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\n result_gt = cv2.warpAffine(gt, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\n\n return result_im, result_gt","def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\n return rotated_data","def random_rotation(image ):\n random_degree = random.uniform(-25, 25)\n padding_mode = random.sample([\"constant\", \"edge\"], 1)[0]\n return rotate(image, random_degree, mode = padding_mode )","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def random_rotate():\n u = np.random.uniform(size=3)\n\n # Random quaternion\n q = np.array([np.sqrt(1-u[0])*np.sin(2*np.pi*u[1]),\n np.sqrt(1-u[0])*np.cos(2*np.pi*u[1]),\n np.sqrt(u[0])*np.sin(2*np.pi*u[2]),\n np.sqrt(u[0])*np.cos(2*np.pi*u[2])])\n \n # Convert the quaternion into a rotation matrix \n rotMat = np.array([[q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3],\n 2*q[1]*q[2] - 2*q[0]*q[3],\n 2*q[1]*q[3] + 2*q[0]*q[2]],\n [2*q[1]*q[2] + 2*q[0]*q[3],\n q[0]*q[0] - q[1]*q[1] + q[2]*q[2] - q[3]*q[3],\n 2*q[2]*q[3] - 2*q[0]*q[1]],\n [2*q[1]*q[3] - 2*q[0]*q[2],\n 2*q[2]*q[3] + 2*q[0]*q[1],\n q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]]])\n return rotMat","def rotate_point_cloud_by_angle(self, data, rotation_angle):\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n rotated_data = np.dot(data, rotation_matrix)\n\n return rotated_data","def test_d_3():\n rs = 20\n d = 3\n np.random.seed(rs)\n number_rotations = 3\n\n theta_1 = np.random.uniform(0, 2 * math.pi)\n rotation_1 = np.identity(d)\n pos_1 = np.random.randint(0, d - 1)\n pos_2 = np.random.randint(pos_1 + 1, d)\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\n\n theta_2 = np.random.uniform(0, 2 * math.pi)\n rotation_2 = np.identity(d)\n pos_3 = np.random.randint(0, d - 1)\n pos_4 = np.random.randint(pos_3 + 1, d)\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\n\n theta_3 = np.random.uniform(0, 2 * math.pi)\n rotation_3 = np.identity(d)\n pos_5 = np.random.randint(0, d - 1)\n pos_6 = np.random.randint(pos_5 + 1, d)\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\n\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\n np.random.seed(rs)\n rotation_function = (mt_obj.calculate_rotation_matrix\n (d, number_rotations))\n assert(np.all(final_rotation == rotation_function))","def augument_data(data_dir, center, left, right, steering_angle):\n image, steering_angle = choose_random_image(data_dir, center, left, right, steering_angle)\n # Randomly flipt the image horizontally and adjust the steering angle.\n if np.random.rand() < 0.5:\n image = cv2.flip(image, 1)\n steering_angle = -steering_angle\n \n #translate the object with random distance in x and y direction and adjust the steering angle\n trans_x = np.random.uniform(0, 30)\n trans_y = np.random.uniform(0, 20)\n steering_angle += trans_x * 0.002\n trans_matrix = np.float32([[1, 0, trans_x], [0, 1, trans_y]])\n height= image.shape[0]\n width=image.shape[1]\n image = cv2.warpAffine(image, trans_matrix, (width, height))\n return image, steering_angle","def random_rotation_matrix():\n\n x = np.random.uniform(size=3)\n theta = x[0]*2*math.pi\n phi = x[1]*2*math.pi\n z = x[2]*2\n\n r = math.sqrt(z)\n vx = math.sin(phi)*r\n vy = math.cos(phi)*r\n vz = math.sqrt(2.0-z)\n\n st = math.sin(theta)\n ct = math.cos(theta)\n\n sx = vx*ct-vy*st\n sy = vx*st+vy*ct\n\n return np.array([[vx*sx-ct, vx*sy-st, vx*vz],\n [vy*sx+st, vy*sy-ct, vy*vz],\n [vz*sx,vz*sy,1.0-z]])","def test_rotating_phantom(self):\n cheese = TomoCheese.from_demo_images()\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\n for img in cheese.dicom_stack:\n img.array = rotate(img.array, angle=3, mode=\"edge\")\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)","def random_rotation_2d(batch, max_angle):\n size = batch.shape\n batch = np.squeeze(batch)\n batch_rot = np.zeros(batch.shape)\n for i in range(batch.shape[0]):\n if bool(random.getrandbits(1)):\n image = np.squeeze(batch[i])\n angle = random.uniform(-max_angle, max_angle)\n batch_rot[i] = scipy.ndimage.interpolation.rotate(image, angle, mode='nearest', reshape=False)\n else:\n batch_rot[i] = batch[i]\n return batch_rot.reshape(size)","def _rotate(self):\n new_points = list()\n for i in range(len(self._points)):\n x = self._points[i][0]\n y = self._points[i][1]\n new_x = self._center[0] + self._center[1] - y\n new_y = self._center[1] - self._center[0] + x\n new_points.append((new_x, new_y))\n return new_points","def random_rotation(x, rg, row_axis=0, col_axis=1, channel_axis=2,\n fill_mode='nearest', cval=0., interpolation_order=1):\n theta = np.random.uniform(-rg, rg)\n x = apply_affine_transform(x, theta=theta, channel_axis=channel_axis,\n fill_mode=fill_mode, cval=cval,\n order=interpolation_order)\n return x","def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n shape_pc = batch_data[k, ...]\n rotation_matrix = rotation_matrices[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def Generate_Random( self ):\n print( 'Generating Random coordinates' )\n stands = self.Data.Stand.keys()\n stands.sort()\n for s in stands:\n trees = self.Data.Stand[s].Tree.keys()\n trees.sort()\n for t in trees:\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )","def rotate(self,X):\n alpha = random.rand() * 2*pi\n beta = self.beta_sample()\n R = Rotator.rotation_matrix(alpha,beta,0.0)\n X = np.dot(R, X)\n if self.random_flip and (random.rand() > 0.5):\n X[2,:] = -X[2,:]\n X[1,:] = -X[1,:]\n return X","def generate_random_DC_MT():\n # Specify DC moment tensor to rotate:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n # And rotate DC moment tensor by random 3D angle:\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\n # And normallise so that moment tensor magnitude = 1:\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\n return random_DC_six_MT_normalised","def rotate_random(tile):\n return rotate(tile, random.choice([0, 1, 2, 3]))","def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\n return rotated_data","def image_rotate(Xb, batch_size):\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\n delta = 30. * intensity # scale by self.intensity\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\n return Xb","def rotate_augmentation():\n rand_rotate = np.random.randint(180)\n return lambda image: rotate_with_extension(image, rand_rotate)","def augment_cloud(Ps):\n \"Augmented params:\"\n pc_augm_scale=0\n pc_augm_rot=1\n pc_augm_mirror_prob=0.5\n pc_augm_jitter=0\n\n M = transforms3d.zooms.zfdir2mat(1)\n if pc_augm_scale > 1:\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\n if pc_augm_rot:\n angle = random.uniform(0, 2*math.pi)\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\n result = []\n for P in Ps:\n P[:,:3] = np.dot(P[:,:3], M.T)\n\n if pc_augm_jitter:\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\n result.append(P)\n return result","def randomizePlayerPose(transform, arena_radius=8):\n initial_r = arena_radius * random.random()\n initial_theta = 2 * math.pi * random.random()\n initial_x = initial_r * math.cos(initial_theta)\n initial_y = initial_r * math.sin(initial_theta)\n initial_rotation = 2 * math.pi * random.random()\n transform.translation.x = initial_x\n transform.translation.y = initial_y\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])","def rotate(self, z_dim=False):\n self.x_displacement = np.format_float_scientific(\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\n )\n self.y_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\n )\n zd = z_dim\n if zd == True:\n self.z_angle = random.uniform(1, 180)\n self.z_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\n )\n else:\n self.z_displacement = 0\n self.z_angle = 0\n return [self.x_displacement, self.y_displacement, self.z_displacement]","def test_rot(self):\n\n print(\"rot()\")\n obs = self.fixture\n\n # rotation(0) = identity\n for axis in [1, 2, 3]:\n # theta = 0.0\n rotation = obs.rot(0.0, axis)\n # find || eye - rot1 ||\n diff = np.linalg.norm(np.eye(3) - rotation)\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\n # theta = 2*pi\n rotation = obs.rot(2.0 * np.pi, axis)\n # find || eye - rot1 ||\n diff = np.linalg.norm(np.eye(3) - rotation)\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\n\n # perform many randomized tests\n num_tests = 100\n num_products = 10\n for _test_counter in range(num_tests):\n thetas = []\n axes = []\n base = np.eye(3)\n # we will multiply a series of rotations into \"base\"\n rot_all = base\n for _rot_counter in range(num_products):\n theta = np.random.uniform(2 * np.pi) # in [0,2 pi]\n axis = np.random.randint(3) + 1 # in {1,2,3}\n axes.append(axis)\n thetas.append(theta)\n rotation = obs.rot(theta, axis)\n # multiply rot1 into the cumulative rotation\n rot_all = np.dot(rot_all, rotation)\n # now, back all the rotations out\n for _rot_counter in range(num_products):\n theta = thetas.pop()\n axis = axes.pop()\n # apply the inverse rotation\n rotation = obs.rot(-theta, axis)\n rot_all = np.dot(rot_all, rotation)\n # find || base - rot1 * rot2 ||\n diff = np.linalg.norm(base - rot_all)\n self.assertAlmostEqual(diff, 0.0, delta=1e-10 * num_products)","def generate_random_rot():\n from pyso3.quaternion import quat2rot\n import numpy as np\n q = np.random.randn(4)\n q = q / np.linalg.norm(q)\n return quat2rot(q)","def random_rotation(x, rg, row_axis=1, col_axis=2, channel_axis=0,\n fill_mode='nearest', cval=0.):\n theta = np.pi / 180 * np.random.uniform(-rg, rg)\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n\n h, w = x.shape[row_axis], x.shape[col_axis]\n transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\n return x","def generate(self):\n inside = self.crystal.is_inside(self.x,self.y,self.z)\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\n return self.rot.rotate(X)","def RotateCopyPlanes(tot_ang,count,init_planes,dir_vec):\n if isinstance(init_planes,Rhino.Geometry.Plane): init_planes=[init_planes]\n inc=tot_ang/(count-1)\n origin=Rhino.Geometry.Point3d(0,0,0)\n planes=[]\n objs=[]\n for i in range(count):\n for init_plane in init_planes:\n new_plane=Rhino.Geometry.Plane(init_plane)\n new_plane.Rotate(inc*i,dir_vec,origin)\n planes.append(new_plane)\n return planes","def spread_quaternions(points,num=100,quats_per_step=100):\n quats = np.zeros((num,4))\n rot_points = np.zeros((num,points.shape[0],3))\n quats[0,:] = [0,0,0,1]\n rot_points[0,:,:] = points\n for ix in range(1,num):\n rand_quats = random_quaternions(quats_per_step) \n positioned = rotate_points(points,rand_quats) \n dists = point_dists(rot_points[:ix],positioned)\n new_rot = np.argmax(dists) \n quats[ix,:]=rand_quats[new_rot,:]\n rot_points[ix,:,:] = positioned[new_rot,:,:]\n \n return quats,rot_points","def rotate_img(img, random):\n degrees = 45 * (random - 0.5)\n h, w = (int(2 * i / 3) for i in img.shape[:2])\n img = imutils.rotate_bound(img, degrees)\n h2, w2 = img.shape[:2]\n x = int((w2 - w) / 2)\n y = int((h2 - h) / 2)\n img = img[y:y + h, x:x + w]\n return img","def shuffle(self):\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\n perm = np.random.permutation(self.X_data.shape[0])\n for old_idx, new_idx in enumerate(perm):\n new_X[new_idx] = self.X_data[old_idx]\n new_Y[new_idx] = self.Y_data[old_idx]\n self.X_data = new_X\n self.Y_data = new_Y","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def random_translation(canvas, img):","def rotate(im: Image) -> Image:\n return im.rotate(random.randint(0, 360))","def rotate_array_deterministic(data):\n return np.concatenate(\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)","def mutate_point_poly3(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def rotate_shape(shape, xy_center, angle_degrees):","def randomize(data):\r\n permutation = np.random.permutation(data.shape[0])\r\n shuffled_data = data[permutation, :]\r\n # shuffled_y = y[permutation]\r\n return shuffled_data","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def random_transform(rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask, rdrs_contains_month=False, border_masking=0, p=0.5):\n if random.random() < p:\n angle = random.randint(-180, 180)\n horizontal_flip = random.choice([True, False])\n vertical_flip = random.choice([True, False])\n transformed_tensors = []\n for tensor in [rdrs_batch, geophysical_batch, y_batch, y_means, train_mask.float(), val_mask.float()]:\n images = [TF.to_pil_image(image, mode='F') for image in tensor.reshape((-1,*tensor.shape[-2:]))]\n images = [TF.rotate(image, angle) for image in images]\n images = [TF.hflip(image) for image in images] if horizontal_flip else images\n images = [TF.vflip(image) for image in images] if vertical_flip else images\n \n transformed_tensors.append(torch.cat([TF.to_tensor(image) for image in images]).reshape(tensor.shape))\n \n rdrs_transformed, geophysical_transformed, y_transformed, \\\n y_means_transformed, train_mask_transformed, val_mask_transformed = transformed_tensors\n \n # Fix \"month\" features that are all-0/all-1 images\n if rdrs_contains_month:\n rdrs_transformed[:,:,-12:] = rdrs_batch[:,:,-12:]\n \n # Do not consider subbasins that are rotated almost out of the image for training\n border_mask = torch.zeros(train_mask.shape, dtype=torch.bool)\n border_mask[border_masking:-border_masking,border_masking:-border_masking] = True\n return rdrs_transformed, geophysical_transformed, y_transformed, y_means_transformed, \\\n train_mask_transformed.bool() & border_mask, val_mask_transformed.bool() & border_mask\n \n return rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask","def rotate_3dcloud(cloud):\n theta = np.radians(90)\n c, s = np.cos(theta), np.sin(theta)\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\n return cloud.dot(Rx.T)","def rotate_crossover(population):\r\n global chromosome_length\r\n global decryption_key\r\n\r\n new_population = []\r\n\r\n decryption_key += rotate_crossover_del\r\n\r\n # predefined rotation value, varied every round\r\n rotation_offset = random.randint(1, chromosome_length)\r\n\r\n decryption_key += rotation_offset_del + str(rotation_offset) + rotation_offset_del\r\n\r\n decryption_key += rotation_types_del\r\n\r\n for chromosome in population:\r\n\r\n p = random.uniform(0, 1)\r\n\r\n if p > 0.5:\r\n decryption_key += \"right|\"\r\n right_first = chromosome[0: len(chromosome) - rotation_offset]\r\n right_second = chromosome[len(chromosome) - rotation_offset:]\r\n new_population.append(right_second + right_first)\r\n else:\r\n decryption_key += \"left|\"\r\n left_first = chromosome[0: rotation_offset]\r\n left_second = chromosome[rotation_offset:]\r\n new_population.append(left_second + left_first)\r\n\r\n decryption_key += rotation_types_del\r\n\r\n decryption_key += rotate_crossover_del\r\n\r\n return new_population","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]","def reset(self):\n self.x = random.uniform(-0.05, 0.05)\n self.x_dot = random.uniform(-0.05, 0.05)\n self.theta = random.uniform(-0.05, 0.05)\n self.theta_dot = random.uniform(-0.05, 0.05)","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def __randomize_data(self):\n times = map(lambda (t, _): t, self.data)\n coords = map(lambda (_, c): c, self.data)\n return zip(times, map(DataGen.__randomize_coord, coords))","def test_rotate_up(self):\n # Testing 'up' rotation clockwise\n side = 'U'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def rotation3(size=None): # noqa\n if size is None:\n size = ()\n else:\n try:\n size = tuple(size)\n except TypeError:\n size = (size,)\n theta, phi, z = 2. * random((3, 1) + size)\n theta *= pi # Initial rotation angle about z-axis.\n phi *= pi # Angle in xy plane for tilt of z-axis.\n # Magnitude of tilt is random variable z.\n r = sqrt(z)\n v = concatenate((r*sin(phi), r*cos(phi), sqrt(2.-z)))\n st, ct = sin(theta), cos(theta)\n s = concatenate((v[0]*ct - v[1]*st, v[0]*st + v[1]*ct))\n m = v[:, newaxis].repeat(3, axis=1)\n m[:, :2] *= s\n m[0, :2] -= concatenate((ct, st))\n m[1, :2] += concatenate((st, -ct))\n m[:2, 2] *= v[2]\n m[2, 2] = 1. - z # Equals v[2]*v[2] - 1.\n if m.ndim > 2:\n m = transpose(m, roll(range(m.ndim), -2)).copy()\n return m","def random_transform_extension(self, x, y, seed=None):\n # x is a single image, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n # use composition of homographies\n # to generate final transform that needs to be applied\n if self.rotation_range:\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(-self.shear_range, self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\n\n transform_matrix = None\n if theta != 0:\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n transform_matrix = rotation_matrix\n\n if tx != 0 or ty != 0:\n shift_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\n\n if shear != 0:\n shear_matrix = np.array([[1, -np.sin(shear), 0],\n [0, np.cos(shear), 0],\n [0, 0, 1]])\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\n\n if zx != 1 or zy != 1:\n zoom_matrix = np.array([[zx, 0, 0],\n [0, zy, 0],\n [0, 0, 1]])\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\n\n if transform_matrix is not None:\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n if self.channel_shift_range != 0:\n x = image.random_channel_shift(x,\n self.channel_shift_range,\n img_channel_axis)\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_col_axis)\n y = kimage.flip_axis(y, img_col_axis)\n\n if self.vertical_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_row_axis)\n y = kimage.flip_axis(y, img_row_axis)\n return x, y","def random_transpose(pianoroll):\n semitone = np.random.randint(-5, 6)\n if semitone > 0:\n pianoroll[:, semitone:, 1:] = pianoroll[:, :-semitone, 1:]\n pianoroll[:, :semitone, 1:] = 0\n elif semitone < 0:\n pianoroll[:, :semitone, 1:] = pianoroll[:, -semitone:, 1:]\n pianoroll[:, semitone:, 1:] = 0\n return pianoroll","def generate_random_MT_Lune_samp():\n # 1. Get randomly varied Lune parameters (gamma and delta):\n # Define U rotation matrix (See Tape and Tape 2012/2013):\n U_rot_matrix = (1./np.sqrt(6))*np.vstack(([np.sqrt(3.),0.,-np.sqrt(3.)],[-1.,2.,-1.], [np.sqrt(2.),np.sqrt(2.),np.sqrt(2.)]))\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random delta and gamma Lune angles:\n delta = np.random.uniform(-np.pi/2., np.pi/2.) # theta, but shifted to range between -pi/2 and pi/2 (See Tape and Tape 2012/2013)\n beta = (np.pi/2.) - delta # Beta is simply phase shift of delta (See Tape and Tape 2012/2013)\n gamma = np.random.uniform(-np.pi/6., np.pi/6.) # phi, but shifted to range between -pi/6 and pi/6 (See Tape and Tape 2012/2013)\n # Get eigenvalues from delta,gamma,beta:\n lune_space_uvw_vec = np.vstack(([np.cos(gamma)*np.sin(beta)], [np.sin(gamma)*np.sin(beta)], [np.cos(beta)]))\n lambda_vec = np.dot(np.transpose(U_rot_matrix), lune_space_uvw_vec) # (See Tape and Tape 2012, eq. 20)\n Lune_space_MT = np.vstack(([lambda_vec[0],0.,0.],[0.,lambda_vec[1],0.], [0.,0.,lambda_vec[2]])) # MT with principle axes in u,v,w Lune space\n # 2. Get theta and phi angles to rotate Lune_space_MT by to randomly rotate into x,y,z space:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z)\n phi = np.arctan2(y,x)\n # 3. Rotate Lune_space_MT from u,v,w coords to x,y,z coords:\n random_MT = rot_mt_by_theta_phi(Lune_space_MT, theta, phi)\n random_six_MT = get_six_MT_from_full_MT_array(random_MT)\n # And normallise so that moment tensor magnitude = 1:\n random_six_MT_normalised = random_six_MT/((np.sum(random_six_MT**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n random_six_MT_normalised = np.reshape(random_six_MT_normalised, (6, 1))\n return random_six_MT_normalised","def test_transform_3d(transform, alpha = 1):\r\n points = 20*[None]\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n points[i] = vec3(x, y, z)\r\n tr_x = random.randrange(-40, 41)\r\n tr_y = random.randrange(-40, 41)\r\n tr_z = random.randrange(-40, 41)\r\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\r\n print(\"Translation\")\r\n print(\"Input\".ljust(30), \"Translation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n th_x = 2*math.pi*random.random()\r\n th_y = 2*math.pi*random.random()\r\n th_z = 2*math.pi*random.random()\r\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\r\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\r\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\r\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\r\n print(\"Rotation\")\r\n print(\"Input\".ljust(30), \"Rotation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\r\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\r\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k = math.exp(2*random.random() - 1)\r\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\r\n print(\"Uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k*x, k*y, k*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k_x = math.exp(2*random.random() - 1)\r\n k_y = 3*random.random() + 1\r\n k_z = 3*random.random() + 1\r\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\r\n else: k_y = k_x + k_y\r\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\r\n else: k_z = (k_x + k_y)/2 + k_z\r\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\r\n print(\"Non-uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()","def mutate_point_circ(mutated_genome):\n seed = random.randint(0,3)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_circ(mutated_genome,index)\n elif seed == 1:\n shift_point_circ(mutated_genome,index)\n elif seed == 2:\n move_radius_circ(mutated_genome,index)\n else: #seed == 3:\n shift_radius_circ(mutated_genome,index)","def generate_random_DC_single_force_coupled_tensor():\n # 1. --- Specify DC moment tensor to rotate ---:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # 2. --- Specify single force 3-vector in same direction as slip of DC solution ---:\n NED_single_force_vector_to_rotate = np.array([1.,0.,0.], dtype=float)\n # 3. --- Rotate DC moment tensor and single force by same random rotation on sphere:\n # 3.a. Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n # 3.b. Rotate DC moment tensor by random 3D angle:\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5) # And normallise so that moment tensor magnitude = 1\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1)) # And set to correct dimensions (so matrix multiplication in forward model works correctly)\n # 3.c. Rotate Single force 3-vector by the same random 3D angle:\n random_coupled_NED_single_force = rot_single_force_by_theta_phi(NED_single_force_vector_to_rotate, theta, phi)\n random_coupled_single_force = np.array([random_coupled_NED_single_force[1], random_coupled_NED_single_force[0], random_coupled_NED_single_force[2]]) # Convert single force from NED coords to END coords (as that is what greens functions are in)\n random_coupled_single_force = np.reshape(random_coupled_single_force, (3, 1))\n # 4. --- Get random fraction amplitude DC and single force components (sum of amplitudes is to 1) ---:\n random_amp_frac = random.random() # random number between 0. and 1.\n random_DC_six_MT_normalised = random_DC_six_MT_normalised*random_amp_frac\n random_coupled_single_force = random_coupled_single_force*(1.-random_amp_frac)\n # 5. --- Finally combine to tensor of length 9 ---:\n random_DC_single_force_coupled_tensor = np.vstack((random_DC_six_MT_normalised, random_coupled_single_force))\n return random_DC_single_force_coupled_tensor, random_amp_frac","def rotate_points(points, rot):\n t0 = time.time()\n points_rot = points.transpose()\n points_rot = rot @ points_rot\n points_rot = points_rot.transpose()\n # print(f\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\")\n return points_rot","def rotateZ(self, *args, **kwargs):\n ...","def _random_permutation(self):\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))","def sample_direction():\r\n gamma = random.random()\r\n mu = 2*gamma-1\r\n gamma = random.random()\r\n phi = 2*np.pi*gamma\r\n direction = [np.sqrt(1-mu**2)*np.cos(phi), np.sqrt(1-mu**2)*np.sin(phi), mu]\r\n return direction","def random_params_gen(self) -> TransformParams:\n while True:\n do_hor_flip = self.horizontal_flip and (np.random.random() < 0.5)\n do_vert_flip = self.vertical_flip and (np.random.random() < 0.5)\n\n yield TransformParams(do_hor_flip=do_hor_flip,\n do_vert_flip=do_vert_flip)","def repick(g1_x, g1_y, g1_z):\n i = random.randint(0, len(g1_x) - 1)\n x = g1_x[i]\n y = g1_y[i]\n z = g1_z[i]\n return x, y, z","def mutate_point_trig(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_trig(mutated_genome,index)\n else: #seed == 1:\n shift_point_trig(mutated_genome,index)","def randomcorners():\n r = lambda x: random.randint(int(x*0.4), int(x*0.6))\n cx = r(gs.DEFAULTS['width'])\n cy = r(gs.DEFAULTS['height'])\n\n w = int(gs.DEFAULTS['width'] * random.random() * 0.2)\n h = int(gs.DEFAULTS['height'] * random.random() * 0.2)\n\n rcrns = [(cx-w, cy-h), (cx+w, cy-h), (cx+w, cy+h), (cx-w, cy+h)]\n random.shuffle(rcrns)\n\n return rcrns","def rotate_points(points,quaternions):\n \n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \n res[:,:,1:] = points \n conjugates = conjugate(quaternions) \n \n for ix in range(len(points)):\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\n return res[:,:,1:]","def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\n # get a random angle\n angle = np.random.randint(0, self.rotate)\n # get a random sign for the angle\n sign = np.random.randint(0, 2)\n x = rotate(x, -sign * angle, reshape=False)\n m = rotate(m, -sign * angle, axes=(0, 1),\n mode='nearest',\n reshape=False)\n return x, m","def test_random_transform():\n # given\n train = pd.read_csv('source/train.csv')\n train['labels'] = train['labels'].map(ast.literal_eval)\n image_path = os.path.join('source', train.iloc[0].path)\n all_labels = train.iloc[0]['labels']\n for label in all_labels:\n if label['class'] == 'whiteboard':\n break\n xn = [int(float(x)) for x in label['xn'].split(';')][:4]\n yn = [int(float(y)) for y in label['yn'].split(';')][:4]\n labels = np.zeros((4, 2))\n for i in range(4):\n labels[i, 0] = xn[i]\n labels[i, 1] = yn[i]\n img = cv2.imread(image_path)\n kw = dict(rotation_range=15,\n height_shift_range=0.2,\n width_shift_range=0.2,\n shear_range=0.3,\n channel_shift_range=0.2,\n horizontal_flip=True,\n vertical_flip=True,\n dim_ordering='tf',\n seed=1313)\n # when\n rimg, rlabels = image_generator.random_transform(img, labels, **kw)\n\n # then just assert transformation isn't changed much\n assert MultiPoint([[224.91875347, 58.05657097],\n [673.57648317, 189.27244333],\n [544.23308452, 381.12743459],\n [70.73339963, 312.7359806]]\n ).equals_exact(rlabels, 5)","def generate_random_DC_crack_coupled_tensor():\n # 1. Generate random DC MT and crack MT:\n # generate DC MT:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\n # Get between small range:\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\n random_num = random.random()\n if random_num <= 0.5:\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\n elif random_num > 0.5:\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n # And redistribute evenly everywhere on boundary:\n random_num = random.random()\n if random_num>0.25 and random_num<=0.5:\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\n if random_num>0.5 and random_num<=0.75:\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\n if random_num>0.75 and random_num<=1.0:\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\n # --- ---\n # random_num = random.random()\n # if random_num <= 0.5:\n # theta_lune_sphere = random.random()*np.pi/2.\n # elif random_num > 0.5:\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\n # random_num = random.random()\n # if random_num <= 0.5:\n # phi_lune_sphere = np.pi/6.\n # elif random_num > 0.5:\n # phi_lune_sphere = -1.*np.pi/6.\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\n # 2. Combine DC and crack tensors:\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\n # 3. Randomly rotate DC-crack MT to random orientation:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\n # 4. Normalise and get 6 MT:\n # Get 6 MT:\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\n # And normallise so that moment tensor magnitude = 1:\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\n return DC_crack_six_MT_rotated_normalised, random_amp_frac","def rotateZ(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n x = self.x * cosa - self.y * sina\r\n y = self.x * sina + self.y * cosa\r\n return Point3D(x, y, self.z)","def orient_point_cloud_to_ground_plane(xyz_arr, roi_point_cloud, thetas, phis, num_points, num_planes, memory):\n\tcenter, plane, phi, theta = get_orientation(roi_point_cloud, num_points, num_planes)\n\tthetas = np.append(thetas, theta)\n\tphis = np.append(phis, phi)\n\t# print(center, plane, np.median(theta), np.median(phis))\n\tCameraPosition['elevation'] = np.median(thetas)\n\tCameraPosition['azimuth'] = np.median(phis)\n\tif thetas.size > memory:\n\t\tthetas = thetas[1:]\n\tif phis.size > memory:\n\t\tphis = phis[1:]\n\tf = open(localization_dir + '%d.json' % len(os.listdir(localization_dir)),'w')\n\tf.write(json.dumps(CameraPosition))\n\tf.close()\n\tcenter = apply_camera_orientation(center, CameraPosition)\n\tplane = apply_camera_orientation(plane, CameraPosition)\n\txyz_arr = apply_camera_matrix_orientation(xyz_arr, CameraPosition)\n\treturn xyz_arr, roi_point_cloud, center","def random_perm3(data_x, data_y, data_z):\n data_size = data_y.shape[0]\n rand_perm = np.arange(data_size)\n np.random.shuffle(rand_perm)\n random_data_x = []\n random_data_z = []\n for indices in rand_perm: # 'List' object, more complicated !!!\n random_data_x.append(data_x[indices])\n random_data_z.append(data_z[indices])\n # random_data_x = data_x[rand_perm]\n random_data_y = data_y[rand_perm]\n # random_data_z = data_z[rand_perm]\n return random_data_x, random_data_y, random_data_z","def random_point():\n theta = numpy.arccos(2. * numpy.random.random() - 1)\n phi = 2 * numpy.pi * numpy.random.random()\n return theta, phi","def randomize(self, amplitude):\n from random import gauss\n # update alignment from projections\n self.getMarkersFromTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\n\n # add random amplitude\n # markers\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\n for (imark, mark) in enumerate(self._Markers):\n if (imark + 1) != irefmark:\n r = mark.get_r()\n for ii in range(0, 3):\n r[ii] = gauss(0, amplitude) + r[ii]\n self._Markers[imark].set_r(r)\n\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\n # translations, rotations, magnifications\n for itilt in range(0, self._ntilt):\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\n if (self._projIndices[itilt] != ireftilt):\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\n\n # update alignment from projections\n self.setMarkersInTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n R = Rotator.rotation_matrix(alpha,0.0,0.0)\n return np.dot(R,X)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n\n beta = np.arccos(1.0-2*random.rand())\n psi = random.rand() * 2*pi\n\n R = Rotator.rotation_matrix(alpha,beta,psi)\n return np.dot(R,X)","def generator(samples, batch_size=32, is_training=True):\n num_samples = len(samples)\n\n #vertical, horizontal range for random translation\n x_translate_range = 100\n y_translate_range = 10\n\n while 1: # Loop forever so the generator never terminates\n #shuffle the samples once the whole data is processed into batches\n shuffle(samples)\n #split data into batches\n for offset in range(0, num_samples, batch_size):\n batch_samples = samples[offset:offset+batch_size]\n images = []\n angles = []\n for batch_sample in batch_samples:\n # corrections for centered view image, left camera view image and right camera view image\n corrections = [0,0.2,-0.2]\n # iterate over center, right and left camera view images\n for i in range(3):\n current_path = get_image_path(batch_sample[i])\n\n # read image\n image = cv2.imread(current_path)\n # append image for training/validation\n images.append(preprocess(image))\n\n # calculate angle measurement with applied angle corrections\n measurement = float(batch_sample[3]) + corrections[i]\n angles.append(measurement)\n\n # insert flipped image for opposite direction generalization\n images.append(preprocess(cv2.flip(image, 1)))\n angles.append(measurement*-1.0)\n\n # create random augmented image only for training\n if is_training:\n image, measurement = flip_image(image, measurement, flip_probability=0.5)\n image = add_salt_pepper_noise(image)\n image, measurement = random_translate(image, measurement, x_translate_range, y_translate_range)\n image = random_shadow(image)\n image = random_brightness(image)\n images.append(preprocess(image))\n angles.append(measurement)\n\n # create X, y dataset\n X_train = np.array(images)\n y_train = np.array(angles)\n\n yield sklearn.utils.shuffle(X_train, y_train)","def __call__(self, results):\n if np.random.rand() > self.prob:\n return results\n h, w = results['image'].shape[:2]\n center = self.center\n if center is None:\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\n angle = random_negative(self.angle, self.random_negative_prob)\n self._rotate_img(results, angle, center, self.scale)\n return results","def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\n def genPos():\n r = radius_scale * self.np_random.rand() + radius_offset\n a = -np.pi * angle_scale + angle_offset\n b = np.pi * angle_scale + angle_offset\n ang = (b - a) * self.np_random.rand() + a\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\n def isNear(pos, poss):\n for p, o in poss:\n if np.linalg.norm(p - pos) < near_distance:\n return True\n return False\n def genPosRetry(poss):\n for i in range(retry):\n pos = genPos()\n if not isNear(pos, poss):\n return pos\n return genPos()\n poss = []\n for i in range(num):\n pos = genPosRetry(poss)\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\n poss.append((pos, orn))\n self.np_random.shuffle(poss)\n return poss"],"string":"[\n \"def rotate_point_cloud(data):\\n rotated_data = np.zeros(data.shape, dtype=np.float32)\\n for k in xrange(data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def random_rotate(self):\\r\\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\\r\\n flip = rand.randrange(0, 2, 1) # 0, 1\\r\\n new_seed = copy.deepcopy(self)\\r\\n # rotate by 90 degrees * rotation (0, 90, 180 270)\\r\\n new_seed.cells = np.rot90(new_seed.cells, rotation) \\r\\n if (flip == 1):\\r\\n # flip upside down\\r\\n new_seed.cells = np.flipud(new_seed.cells)\\r\\n new_seed.xspan = new_seed.cells.shape[0]\\r\\n new_seed.yspan = new_seed.cells.shape[1]\\r\\n return new_seed\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k,:,0:3]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def RotatePointCloud(batch_data):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1],])\\n return np.dot(batch_data, rotation_matrix)\",\n \"def rotate_point_cloud_in_plane(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, -sinval, 0],\\n [sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\\n ## https://en.wikipedia.org/wiki/Rotation_matrix\\n if(use_rotation_tensor != True):\\n angle_range = DEGREES\\n x_angle = radians(random.random() * angle_range)\\n y_angle = radians(random.random() * angle_range)\\n z_angle = radians(random.random() * angle_range)\\n\\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\\n rotation_matrix = torch.mm(rot_y, rot_z)\\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \\n\\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n \\n \\n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\\n self.rotation_matrix = rotation_matrix\\n \\n if(save_rotation_tensor):\\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \\n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\\n else: \\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\\n return pointcloud_model_rotated[:,:,0:3]\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n # rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]]) # rotate along y axis\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data, batch_label):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\\n return rotated_data, rotated_label\",\n \"def randomize_trajectory(self):\\n self.angle = randint(-360, 360)\\n self.speed = randint(1, 5)/2.5\",\n \"def random_rotation(self, img, p = 0.5):\\n if self.decision(p):\\n theta = random.randrange(-15, 15)\\n phi = random.randrange(-15, 15)\\n gamma = random.randrange(-15, 15)\\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\\n # check if cut is ahve to much dark pixels, more then 20 %\\n non_zeros = np.count_nonzero(roi)\\n non_zeros_procent = non_zeros / roi.size\\n if non_zeros_procent < 0.8:\\n pass\\n else:\\n img = roi\\n return img\",\n \"def _get_random_transform(self, img_shape, seed=None):\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if self.rotation_range:\\n theta = np.random.uniform(\\n -self.rotation_range,\\n self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n try: # 1-D array-like or int\\n tx = np.random.choice(self.height_shift_range)\\n tx *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n tx = np.random.uniform(-self.height_shift_range,\\n self.height_shift_range)\\n if np.max(self.height_shift_range) < 1:\\n tx *= img_shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n try: # 1-D array-like or int\\n ty = np.random.choice(self.width_shift_range)\\n ty *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n ty = np.random.uniform(-self.width_shift_range,\\n self.width_shift_range)\\n if np.max(self.width_shift_range) < 1:\\n ty *= img_shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(\\n -self.shear_range,\\n self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(\\n self.zoom_range[0],\\n self.zoom_range[1],\\n 2)\\n\\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\\n\\n channel_shift_intensity = None\\n if self.channel_shift_range != 0:\\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\\n self.channel_shift_range)\\n\\n brightness = None\\n if self.brightness_range is not None:\\n brightness = np.random.uniform(self.brightness_range[0],\\n self.brightness_range[1])\\n\\n transform_parameters = {'theta': theta,\\n 'tx': tx,\\n 'ty': ty,\\n 'shear': shear,\\n 'zx': zx,\\n 'zy': zy,\\n 'flip_horizontal': flip_horizontal,\\n 'flip_vertical': flip_vertical,\\n 'channel_shift_intensity': channel_shift_intensity,\\n 'brightness': brightness}\\n\\n return transform_parameters\",\n \"def random_rotation(image, gt, normal=False, random_state=None):\\n if random_state is None:\\n random_state = np.random.RandomState(None)\\n\\n degree = int(random_state.normal(0, 10)) if normal else random_state.randint(-10, 10)\\n rows, cols = image.shape[:2]\\n\\n mat = cv2.getRotationMatrix2D((cols / 2, rows / 2), degree, 1)\\n result_im = cv2.warpAffine(image, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\\n result_gt = cv2.warpAffine(gt, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\\n\\n return result_im, result_gt\",\n \"def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def random_rotation(image ):\\n random_degree = random.uniform(-25, 25)\\n padding_mode = random.sample([\\\"constant\\\", \\\"edge\\\"], 1)[0]\\n return rotate(image, random_degree, mode = padding_mode )\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def random_rotate():\\n u = np.random.uniform(size=3)\\n\\n # Random quaternion\\n q = np.array([np.sqrt(1-u[0])*np.sin(2*np.pi*u[1]),\\n np.sqrt(1-u[0])*np.cos(2*np.pi*u[1]),\\n np.sqrt(u[0])*np.sin(2*np.pi*u[2]),\\n np.sqrt(u[0])*np.cos(2*np.pi*u[2])])\\n \\n # Convert the quaternion into a rotation matrix \\n rotMat = np.array([[q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3],\\n 2*q[1]*q[2] - 2*q[0]*q[3],\\n 2*q[1]*q[3] + 2*q[0]*q[2]],\\n [2*q[1]*q[2] + 2*q[0]*q[3],\\n q[0]*q[0] - q[1]*q[1] + q[2]*q[2] - q[3]*q[3],\\n 2*q[2]*q[3] - 2*q[0]*q[1]],\\n [2*q[1]*q[3] - 2*q[0]*q[2],\\n 2*q[2]*q[3] + 2*q[0]*q[1],\\n q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]]])\\n return rotMat\",\n \"def rotate_point_cloud_by_angle(self, data, rotation_angle):\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n rotated_data = np.dot(data, rotation_matrix)\\n\\n return rotated_data\",\n \"def test_d_3():\\n rs = 20\\n d = 3\\n np.random.seed(rs)\\n number_rotations = 3\\n\\n theta_1 = np.random.uniform(0, 2 * math.pi)\\n rotation_1 = np.identity(d)\\n pos_1 = np.random.randint(0, d - 1)\\n pos_2 = np.random.randint(pos_1 + 1, d)\\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\\n\\n theta_2 = np.random.uniform(0, 2 * math.pi)\\n rotation_2 = np.identity(d)\\n pos_3 = np.random.randint(0, d - 1)\\n pos_4 = np.random.randint(pos_3 + 1, d)\\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\\n\\n theta_3 = np.random.uniform(0, 2 * math.pi)\\n rotation_3 = np.identity(d)\\n pos_5 = np.random.randint(0, d - 1)\\n pos_6 = np.random.randint(pos_5 + 1, d)\\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\\n\\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\\n np.random.seed(rs)\\n rotation_function = (mt_obj.calculate_rotation_matrix\\n (d, number_rotations))\\n assert(np.all(final_rotation == rotation_function))\",\n \"def augument_data(data_dir, center, left, right, steering_angle):\\n image, steering_angle = choose_random_image(data_dir, center, left, right, steering_angle)\\n # Randomly flipt the image horizontally and adjust the steering angle.\\n if np.random.rand() < 0.5:\\n image = cv2.flip(image, 1)\\n steering_angle = -steering_angle\\n \\n #translate the object with random distance in x and y direction and adjust the steering angle\\n trans_x = np.random.uniform(0, 30)\\n trans_y = np.random.uniform(0, 20)\\n steering_angle += trans_x * 0.002\\n trans_matrix = np.float32([[1, 0, trans_x], [0, 1, trans_y]])\\n height= image.shape[0]\\n width=image.shape[1]\\n image = cv2.warpAffine(image, trans_matrix, (width, height))\\n return image, steering_angle\",\n \"def random_rotation_matrix():\\n\\n x = np.random.uniform(size=3)\\n theta = x[0]*2*math.pi\\n phi = x[1]*2*math.pi\\n z = x[2]*2\\n\\n r = math.sqrt(z)\\n vx = math.sin(phi)*r\\n vy = math.cos(phi)*r\\n vz = math.sqrt(2.0-z)\\n\\n st = math.sin(theta)\\n ct = math.cos(theta)\\n\\n sx = vx*ct-vy*st\\n sy = vx*st+vy*ct\\n\\n return np.array([[vx*sx-ct, vx*sy-st, vx*vz],\\n [vy*sx+st, vy*sy-ct, vy*vz],\\n [vz*sx,vz*sy,1.0-z]])\",\n \"def test_rotating_phantom(self):\\n cheese = TomoCheese.from_demo_images()\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\\n for img in cheese.dicom_stack:\\n img.array = rotate(img.array, angle=3, mode=\\\"edge\\\")\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)\",\n \"def random_rotation_2d(batch, max_angle):\\n size = batch.shape\\n batch = np.squeeze(batch)\\n batch_rot = np.zeros(batch.shape)\\n for i in range(batch.shape[0]):\\n if bool(random.getrandbits(1)):\\n image = np.squeeze(batch[i])\\n angle = random.uniform(-max_angle, max_angle)\\n batch_rot[i] = scipy.ndimage.interpolation.rotate(image, angle, mode='nearest', reshape=False)\\n else:\\n batch_rot[i] = batch[i]\\n return batch_rot.reshape(size)\",\n \"def _rotate(self):\\n new_points = list()\\n for i in range(len(self._points)):\\n x = self._points[i][0]\\n y = self._points[i][1]\\n new_x = self._center[0] + self._center[1] - y\\n new_y = self._center[1] - self._center[0] + x\\n new_points.append((new_x, new_y))\\n return new_points\",\n \"def random_rotation(x, rg, row_axis=0, col_axis=1, channel_axis=2,\\n fill_mode='nearest', cval=0., interpolation_order=1):\\n theta = np.random.uniform(-rg, rg)\\n x = apply_affine_transform(x, theta=theta, channel_axis=channel_axis,\\n fill_mode=fill_mode, cval=cval,\\n order=interpolation_order)\\n return x\",\n \"def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n shape_pc = batch_data[k, ...]\\n rotation_matrix = rotation_matrices[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def Generate_Random( self ):\\n print( 'Generating Random coordinates' )\\n stands = self.Data.Stand.keys()\\n stands.sort()\\n for s in stands:\\n trees = self.Data.Stand[s].Tree.keys()\\n trees.sort()\\n for t in trees:\\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n beta = self.beta_sample()\\n R = Rotator.rotation_matrix(alpha,beta,0.0)\\n X = np.dot(R, X)\\n if self.random_flip and (random.rand() > 0.5):\\n X[2,:] = -X[2,:]\\n X[1,:] = -X[1,:]\\n return X\",\n \"def generate_random_DC_MT():\\n # Specify DC moment tensor to rotate:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n # And rotate DC moment tensor by random 3D angle:\\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\\n # And normallise so that moment tensor magnitude = 1:\\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\\n return random_DC_six_MT_normalised\",\n \"def rotate_random(tile):\\n return rotate(tile, random.choice([0, 1, 2, 3]))\",\n \"def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def image_rotate(Xb, batch_size):\\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\\n delta = 30. * intensity # scale by self.intensity\\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\\n return Xb\",\n \"def rotate_augmentation():\\n rand_rotate = np.random.randint(180)\\n return lambda image: rotate_with_extension(image, rand_rotate)\",\n \"def augment_cloud(Ps):\\n \\\"Augmented params:\\\"\\n pc_augm_scale=0\\n pc_augm_rot=1\\n pc_augm_mirror_prob=0.5\\n pc_augm_jitter=0\\n\\n M = transforms3d.zooms.zfdir2mat(1)\\n if pc_augm_scale > 1:\\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\\n if pc_augm_rot:\\n angle = random.uniform(0, 2*math.pi)\\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\\n result = []\\n for P in Ps:\\n P[:,:3] = np.dot(P[:,:3], M.T)\\n\\n if pc_augm_jitter:\\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\\n result.append(P)\\n return result\",\n \"def randomizePlayerPose(transform, arena_radius=8):\\n initial_r = arena_radius * random.random()\\n initial_theta = 2 * math.pi * random.random()\\n initial_x = initial_r * math.cos(initial_theta)\\n initial_y = initial_r * math.sin(initial_theta)\\n initial_rotation = 2 * math.pi * random.random()\\n transform.translation.x = initial_x\\n transform.translation.y = initial_y\\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])\",\n \"def rotate(self, z_dim=False):\\n self.x_displacement = np.format_float_scientific(\\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\\n )\\n self.y_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\\n )\\n zd = z_dim\\n if zd == True:\\n self.z_angle = random.uniform(1, 180)\\n self.z_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\\n )\\n else:\\n self.z_displacement = 0\\n self.z_angle = 0\\n return [self.x_displacement, self.y_displacement, self.z_displacement]\",\n \"def test_rot(self):\\n\\n print(\\\"rot()\\\")\\n obs = self.fixture\\n\\n # rotation(0) = identity\\n for axis in [1, 2, 3]:\\n # theta = 0.0\\n rotation = obs.rot(0.0, axis)\\n # find || eye - rot1 ||\\n diff = np.linalg.norm(np.eye(3) - rotation)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\\n # theta = 2*pi\\n rotation = obs.rot(2.0 * np.pi, axis)\\n # find || eye - rot1 ||\\n diff = np.linalg.norm(np.eye(3) - rotation)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\\n\\n # perform many randomized tests\\n num_tests = 100\\n num_products = 10\\n for _test_counter in range(num_tests):\\n thetas = []\\n axes = []\\n base = np.eye(3)\\n # we will multiply a series of rotations into \\\"base\\\"\\n rot_all = base\\n for _rot_counter in range(num_products):\\n theta = np.random.uniform(2 * np.pi) # in [0,2 pi]\\n axis = np.random.randint(3) + 1 # in {1,2,3}\\n axes.append(axis)\\n thetas.append(theta)\\n rotation = obs.rot(theta, axis)\\n # multiply rot1 into the cumulative rotation\\n rot_all = np.dot(rot_all, rotation)\\n # now, back all the rotations out\\n for _rot_counter in range(num_products):\\n theta = thetas.pop()\\n axis = axes.pop()\\n # apply the inverse rotation\\n rotation = obs.rot(-theta, axis)\\n rot_all = np.dot(rot_all, rotation)\\n # find || base - rot1 * rot2 ||\\n diff = np.linalg.norm(base - rot_all)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-10 * num_products)\",\n \"def generate_random_rot():\\n from pyso3.quaternion import quat2rot\\n import numpy as np\\n q = np.random.randn(4)\\n q = q / np.linalg.norm(q)\\n return quat2rot(q)\",\n \"def random_rotation(x, rg, row_axis=1, col_axis=2, channel_axis=0,\\n fill_mode='nearest', cval=0.):\\n theta = np.pi / 180 * np.random.uniform(-rg, rg)\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)\\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\\n return x\",\n \"def generate(self):\\n inside = self.crystal.is_inside(self.x,self.y,self.z)\\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\\n return self.rot.rotate(X)\",\n \"def RotateCopyPlanes(tot_ang,count,init_planes,dir_vec):\\n if isinstance(init_planes,Rhino.Geometry.Plane): init_planes=[init_planes]\\n inc=tot_ang/(count-1)\\n origin=Rhino.Geometry.Point3d(0,0,0)\\n planes=[]\\n objs=[]\\n for i in range(count):\\n for init_plane in init_planes:\\n new_plane=Rhino.Geometry.Plane(init_plane)\\n new_plane.Rotate(inc*i,dir_vec,origin)\\n planes.append(new_plane)\\n return planes\",\n \"def spread_quaternions(points,num=100,quats_per_step=100):\\n quats = np.zeros((num,4))\\n rot_points = np.zeros((num,points.shape[0],3))\\n quats[0,:] = [0,0,0,1]\\n rot_points[0,:,:] = points\\n for ix in range(1,num):\\n rand_quats = random_quaternions(quats_per_step) \\n positioned = rotate_points(points,rand_quats) \\n dists = point_dists(rot_points[:ix],positioned)\\n new_rot = np.argmax(dists) \\n quats[ix,:]=rand_quats[new_rot,:]\\n rot_points[ix,:,:] = positioned[new_rot,:,:]\\n \\n return quats,rot_points\",\n \"def rotate_img(img, random):\\n degrees = 45 * (random - 0.5)\\n h, w = (int(2 * i / 3) for i in img.shape[:2])\\n img = imutils.rotate_bound(img, degrees)\\n h2, w2 = img.shape[:2]\\n x = int((w2 - w) / 2)\\n y = int((h2 - h) / 2)\\n img = img[y:y + h, x:x + w]\\n return img\",\n \"def shuffle(self):\\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\\n perm = np.random.permutation(self.X_data.shape[0])\\n for old_idx, new_idx in enumerate(perm):\\n new_X[new_idx] = self.X_data[old_idx]\\n new_Y[new_idx] = self.Y_data[old_idx]\\n self.X_data = new_X\\n self.Y_data = new_Y\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def random_translation(canvas, img):\",\n \"def rotate(im: Image) -> Image:\\n return im.rotate(random.randint(0, 360))\",\n \"def rotate_array_deterministic(data):\\n return np.concatenate(\\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)\",\n \"def mutate_point_poly3(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def randomize(data):\\r\\n permutation = np.random.permutation(data.shape[0])\\r\\n shuffled_data = data[permutation, :]\\r\\n # shuffled_y = y[permutation]\\r\\n return shuffled_data\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def random_transform(rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask, rdrs_contains_month=False, border_masking=0, p=0.5):\\n if random.random() < p:\\n angle = random.randint(-180, 180)\\n horizontal_flip = random.choice([True, False])\\n vertical_flip = random.choice([True, False])\\n transformed_tensors = []\\n for tensor in [rdrs_batch, geophysical_batch, y_batch, y_means, train_mask.float(), val_mask.float()]:\\n images = [TF.to_pil_image(image, mode='F') for image in tensor.reshape((-1,*tensor.shape[-2:]))]\\n images = [TF.rotate(image, angle) for image in images]\\n images = [TF.hflip(image) for image in images] if horizontal_flip else images\\n images = [TF.vflip(image) for image in images] if vertical_flip else images\\n \\n transformed_tensors.append(torch.cat([TF.to_tensor(image) for image in images]).reshape(tensor.shape))\\n \\n rdrs_transformed, geophysical_transformed, y_transformed, \\\\\\n y_means_transformed, train_mask_transformed, val_mask_transformed = transformed_tensors\\n \\n # Fix \\\"month\\\" features that are all-0/all-1 images\\n if rdrs_contains_month:\\n rdrs_transformed[:,:,-12:] = rdrs_batch[:,:,-12:]\\n \\n # Do not consider subbasins that are rotated almost out of the image for training\\n border_mask = torch.zeros(train_mask.shape, dtype=torch.bool)\\n border_mask[border_masking:-border_masking,border_masking:-border_masking] = True\\n return rdrs_transformed, geophysical_transformed, y_transformed, y_means_transformed, \\\\\\n train_mask_transformed.bool() & border_mask, val_mask_transformed.bool() & border_mask\\n \\n return rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask\",\n \"def rotate_3dcloud(cloud):\\n theta = np.radians(90)\\n c, s = np.cos(theta), np.sin(theta)\\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\\n return cloud.dot(Rx.T)\",\n \"def rotate_crossover(population):\\r\\n global chromosome_length\\r\\n global decryption_key\\r\\n\\r\\n new_population = []\\r\\n\\r\\n decryption_key += rotate_crossover_del\\r\\n\\r\\n # predefined rotation value, varied every round\\r\\n rotation_offset = random.randint(1, chromosome_length)\\r\\n\\r\\n decryption_key += rotation_offset_del + str(rotation_offset) + rotation_offset_del\\r\\n\\r\\n decryption_key += rotation_types_del\\r\\n\\r\\n for chromosome in population:\\r\\n\\r\\n p = random.uniform(0, 1)\\r\\n\\r\\n if p > 0.5:\\r\\n decryption_key += \\\"right|\\\"\\r\\n right_first = chromosome[0: len(chromosome) - rotation_offset]\\r\\n right_second = chromosome[len(chromosome) - rotation_offset:]\\r\\n new_population.append(right_second + right_first)\\r\\n else:\\r\\n decryption_key += \\\"left|\\\"\\r\\n left_first = chromosome[0: rotation_offset]\\r\\n left_second = chromosome[rotation_offset:]\\r\\n new_population.append(left_second + left_first)\\r\\n\\r\\n decryption_key += rotation_types_del\\r\\n\\r\\n decryption_key += rotate_crossover_del\\r\\n\\r\\n return new_population\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:,idx,:]\",\n \"def reset(self):\\n self.x = random.uniform(-0.05, 0.05)\\n self.x_dot = random.uniform(-0.05, 0.05)\\n self.theta = random.uniform(-0.05, 0.05)\\n self.theta_dot = random.uniform(-0.05, 0.05)\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def __randomize_data(self):\\n times = map(lambda (t, _): t, self.data)\\n coords = map(lambda (_, c): c, self.data)\\n return zip(times, map(DataGen.__randomize_coord, coords))\",\n \"def test_rotate_up(self):\\n # Testing 'up' rotation clockwise\\n side = 'U'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def rotation3(size=None): # noqa\\n if size is None:\\n size = ()\\n else:\\n try:\\n size = tuple(size)\\n except TypeError:\\n size = (size,)\\n theta, phi, z = 2. * random((3, 1) + size)\\n theta *= pi # Initial rotation angle about z-axis.\\n phi *= pi # Angle in xy plane for tilt of z-axis.\\n # Magnitude of tilt is random variable z.\\n r = sqrt(z)\\n v = concatenate((r*sin(phi), r*cos(phi), sqrt(2.-z)))\\n st, ct = sin(theta), cos(theta)\\n s = concatenate((v[0]*ct - v[1]*st, v[0]*st + v[1]*ct))\\n m = v[:, newaxis].repeat(3, axis=1)\\n m[:, :2] *= s\\n m[0, :2] -= concatenate((ct, st))\\n m[1, :2] += concatenate((st, -ct))\\n m[:2, 2] *= v[2]\\n m[2, 2] = 1. - z # Equals v[2]*v[2] - 1.\\n if m.ndim > 2:\\n m = transpose(m, roll(range(m.ndim), -2)).copy()\\n return m\",\n \"def random_transform_extension(self, x, y, seed=None):\\n # x is a single image, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n # use composition of homographies\\n # to generate final transform that needs to be applied\\n if self.rotation_range:\\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(-self.shear_range, self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\\n\\n transform_matrix = None\\n if theta != 0:\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n transform_matrix = rotation_matrix\\n\\n if tx != 0 or ty != 0:\\n shift_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\\n\\n if shear != 0:\\n shear_matrix = np.array([[1, -np.sin(shear), 0],\\n [0, np.cos(shear), 0],\\n [0, 0, 1]])\\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\\n\\n if zx != 1 or zy != 1:\\n zoom_matrix = np.array([[zx, 0, 0],\\n [0, zy, 0],\\n [0, 0, 1]])\\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\\n\\n if transform_matrix is not None:\\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n if self.channel_shift_range != 0:\\n x = image.random_channel_shift(x,\\n self.channel_shift_range,\\n img_channel_axis)\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_col_axis)\\n y = kimage.flip_axis(y, img_col_axis)\\n\\n if self.vertical_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_row_axis)\\n y = kimage.flip_axis(y, img_row_axis)\\n return x, y\",\n \"def random_transpose(pianoroll):\\n semitone = np.random.randint(-5, 6)\\n if semitone > 0:\\n pianoroll[:, semitone:, 1:] = pianoroll[:, :-semitone, 1:]\\n pianoroll[:, :semitone, 1:] = 0\\n elif semitone < 0:\\n pianoroll[:, :semitone, 1:] = pianoroll[:, -semitone:, 1:]\\n pianoroll[:, semitone:, 1:] = 0\\n return pianoroll\",\n \"def generate_random_MT_Lune_samp():\\n # 1. Get randomly varied Lune parameters (gamma and delta):\\n # Define U rotation matrix (See Tape and Tape 2012/2013):\\n U_rot_matrix = (1./np.sqrt(6))*np.vstack(([np.sqrt(3.),0.,-np.sqrt(3.)],[-1.,2.,-1.], [np.sqrt(2.),np.sqrt(2.),np.sqrt(2.)]))\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random delta and gamma Lune angles:\\n delta = np.random.uniform(-np.pi/2., np.pi/2.) # theta, but shifted to range between -pi/2 and pi/2 (See Tape and Tape 2012/2013)\\n beta = (np.pi/2.) - delta # Beta is simply phase shift of delta (See Tape and Tape 2012/2013)\\n gamma = np.random.uniform(-np.pi/6., np.pi/6.) # phi, but shifted to range between -pi/6 and pi/6 (See Tape and Tape 2012/2013)\\n # Get eigenvalues from delta,gamma,beta:\\n lune_space_uvw_vec = np.vstack(([np.cos(gamma)*np.sin(beta)], [np.sin(gamma)*np.sin(beta)], [np.cos(beta)]))\\n lambda_vec = np.dot(np.transpose(U_rot_matrix), lune_space_uvw_vec) # (See Tape and Tape 2012, eq. 20)\\n Lune_space_MT = np.vstack(([lambda_vec[0],0.,0.],[0.,lambda_vec[1],0.], [0.,0.,lambda_vec[2]])) # MT with principle axes in u,v,w Lune space\\n # 2. Get theta and phi angles to rotate Lune_space_MT by to randomly rotate into x,y,z space:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z)\\n phi = np.arctan2(y,x)\\n # 3. Rotate Lune_space_MT from u,v,w coords to x,y,z coords:\\n random_MT = rot_mt_by_theta_phi(Lune_space_MT, theta, phi)\\n random_six_MT = get_six_MT_from_full_MT_array(random_MT)\\n # And normallise so that moment tensor magnitude = 1:\\n random_six_MT_normalised = random_six_MT/((np.sum(random_six_MT**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n random_six_MT_normalised = np.reshape(random_six_MT_normalised, (6, 1))\\n return random_six_MT_normalised\",\n \"def test_transform_3d(transform, alpha = 1):\\r\\n points = 20*[None]\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n points[i] = vec3(x, y, z)\\r\\n tr_x = random.randrange(-40, 41)\\r\\n tr_y = random.randrange(-40, 41)\\r\\n tr_z = random.randrange(-40, 41)\\r\\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\\r\\n print(\\\"Translation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Translation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n th_x = 2*math.pi*random.random()\\r\\n th_y = 2*math.pi*random.random()\\r\\n th_z = 2*math.pi*random.random()\\r\\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\\r\\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\\r\\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\\r\\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\\r\\n print(\\\"Rotation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Rotation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\\r\\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\\r\\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k = math.exp(2*random.random() - 1)\\r\\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\\r\\n print(\\\"Uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k*x, k*y, k*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k_x = math.exp(2*random.random() - 1)\\r\\n k_y = 3*random.random() + 1\\r\\n k_z = 3*random.random() + 1\\r\\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\\r\\n else: k_y = k_x + k_y\\r\\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\\r\\n else: k_z = (k_x + k_y)/2 + k_z\\r\\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\\r\\n print(\\\"Non-uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\",\n \"def mutate_point_circ(mutated_genome):\\n seed = random.randint(0,3)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_circ(mutated_genome,index)\\n elif seed == 1:\\n shift_point_circ(mutated_genome,index)\\n elif seed == 2:\\n move_radius_circ(mutated_genome,index)\\n else: #seed == 3:\\n shift_radius_circ(mutated_genome,index)\",\n \"def generate_random_DC_single_force_coupled_tensor():\\n # 1. --- Specify DC moment tensor to rotate ---:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # 2. --- Specify single force 3-vector in same direction as slip of DC solution ---:\\n NED_single_force_vector_to_rotate = np.array([1.,0.,0.], dtype=float)\\n # 3. --- Rotate DC moment tensor and single force by same random rotation on sphere:\\n # 3.a. Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n # 3.b. Rotate DC moment tensor by random 3D angle:\\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5) # And normallise so that moment tensor magnitude = 1\\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1)) # And set to correct dimensions (so matrix multiplication in forward model works correctly)\\n # 3.c. Rotate Single force 3-vector by the same random 3D angle:\\n random_coupled_NED_single_force = rot_single_force_by_theta_phi(NED_single_force_vector_to_rotate, theta, phi)\\n random_coupled_single_force = np.array([random_coupled_NED_single_force[1], random_coupled_NED_single_force[0], random_coupled_NED_single_force[2]]) # Convert single force from NED coords to END coords (as that is what greens functions are in)\\n random_coupled_single_force = np.reshape(random_coupled_single_force, (3, 1))\\n # 4. --- Get random fraction amplitude DC and single force components (sum of amplitudes is to 1) ---:\\n random_amp_frac = random.random() # random number between 0. and 1.\\n random_DC_six_MT_normalised = random_DC_six_MT_normalised*random_amp_frac\\n random_coupled_single_force = random_coupled_single_force*(1.-random_amp_frac)\\n # 5. --- Finally combine to tensor of length 9 ---:\\n random_DC_single_force_coupled_tensor = np.vstack((random_DC_six_MT_normalised, random_coupled_single_force))\\n return random_DC_single_force_coupled_tensor, random_amp_frac\",\n \"def rotate_points(points, rot):\\n t0 = time.time()\\n points_rot = points.transpose()\\n points_rot = rot @ points_rot\\n points_rot = points_rot.transpose()\\n # print(f\\\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\\\")\\n return points_rot\",\n \"def rotateZ(self, *args, **kwargs):\\n ...\",\n \"def _random_permutation(self):\\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))\",\n \"def sample_direction():\\r\\n gamma = random.random()\\r\\n mu = 2*gamma-1\\r\\n gamma = random.random()\\r\\n phi = 2*np.pi*gamma\\r\\n direction = [np.sqrt(1-mu**2)*np.cos(phi), np.sqrt(1-mu**2)*np.sin(phi), mu]\\r\\n return direction\",\n \"def random_params_gen(self) -> TransformParams:\\n while True:\\n do_hor_flip = self.horizontal_flip and (np.random.random() < 0.5)\\n do_vert_flip = self.vertical_flip and (np.random.random() < 0.5)\\n\\n yield TransformParams(do_hor_flip=do_hor_flip,\\n do_vert_flip=do_vert_flip)\",\n \"def repick(g1_x, g1_y, g1_z):\\n i = random.randint(0, len(g1_x) - 1)\\n x = g1_x[i]\\n y = g1_y[i]\\n z = g1_z[i]\\n return x, y, z\",\n \"def mutate_point_trig(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_trig(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_trig(mutated_genome,index)\",\n \"def randomcorners():\\n r = lambda x: random.randint(int(x*0.4), int(x*0.6))\\n cx = r(gs.DEFAULTS['width'])\\n cy = r(gs.DEFAULTS['height'])\\n\\n w = int(gs.DEFAULTS['width'] * random.random() * 0.2)\\n h = int(gs.DEFAULTS['height'] * random.random() * 0.2)\\n\\n rcrns = [(cx-w, cy-h), (cx+w, cy-h), (cx+w, cy+h), (cx-w, cy+h)]\\n random.shuffle(rcrns)\\n\\n return rcrns\",\n \"def rotate_points(points,quaternions):\\n \\n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \\n res[:,:,1:] = points \\n conjugates = conjugate(quaternions) \\n \\n for ix in range(len(points)):\\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\\n return res[:,:,1:]\",\n \"def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\\n # get a random angle\\n angle = np.random.randint(0, self.rotate)\\n # get a random sign for the angle\\n sign = np.random.randint(0, 2)\\n x = rotate(x, -sign * angle, reshape=False)\\n m = rotate(m, -sign * angle, axes=(0, 1),\\n mode='nearest',\\n reshape=False)\\n return x, m\",\n \"def test_random_transform():\\n # given\\n train = pd.read_csv('source/train.csv')\\n train['labels'] = train['labels'].map(ast.literal_eval)\\n image_path = os.path.join('source', train.iloc[0].path)\\n all_labels = train.iloc[0]['labels']\\n for label in all_labels:\\n if label['class'] == 'whiteboard':\\n break\\n xn = [int(float(x)) for x in label['xn'].split(';')][:4]\\n yn = [int(float(y)) for y in label['yn'].split(';')][:4]\\n labels = np.zeros((4, 2))\\n for i in range(4):\\n labels[i, 0] = xn[i]\\n labels[i, 1] = yn[i]\\n img = cv2.imread(image_path)\\n kw = dict(rotation_range=15,\\n height_shift_range=0.2,\\n width_shift_range=0.2,\\n shear_range=0.3,\\n channel_shift_range=0.2,\\n horizontal_flip=True,\\n vertical_flip=True,\\n dim_ordering='tf',\\n seed=1313)\\n # when\\n rimg, rlabels = image_generator.random_transform(img, labels, **kw)\\n\\n # then just assert transformation isn't changed much\\n assert MultiPoint([[224.91875347, 58.05657097],\\n [673.57648317, 189.27244333],\\n [544.23308452, 381.12743459],\\n [70.73339963, 312.7359806]]\\n ).equals_exact(rlabels, 5)\",\n \"def generate_random_DC_crack_coupled_tensor():\\n # 1. Generate random DC MT and crack MT:\\n # generate DC MT:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\\n # Get between small range:\\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\\n random_num = random.random()\\n if random_num <= 0.5:\\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\\n elif random_num > 0.5:\\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n # And redistribute evenly everywhere on boundary:\\n random_num = random.random()\\n if random_num>0.25 and random_num<=0.5:\\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\\n if random_num>0.5 and random_num<=0.75:\\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\\n if random_num>0.75 and random_num<=1.0:\\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\\n # --- ---\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # theta_lune_sphere = random.random()*np.pi/2.\\n # elif random_num > 0.5:\\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # phi_lune_sphere = np.pi/6.\\n # elif random_num > 0.5:\\n # phi_lune_sphere = -1.*np.pi/6.\\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\\n # 2. Combine DC and crack tensors:\\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\\n # 3. Randomly rotate DC-crack MT to random orientation:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\\n # 4. Normalise and get 6 MT:\\n # Get 6 MT:\\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\\n # And normallise so that moment tensor magnitude = 1:\\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\\n return DC_crack_six_MT_rotated_normalised, random_amp_frac\",\n \"def rotateZ(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n x = self.x * cosa - self.y * sina\\r\\n y = self.x * sina + self.y * cosa\\r\\n return Point3D(x, y, self.z)\",\n \"def orient_point_cloud_to_ground_plane(xyz_arr, roi_point_cloud, thetas, phis, num_points, num_planes, memory):\\n\\tcenter, plane, phi, theta = get_orientation(roi_point_cloud, num_points, num_planes)\\n\\tthetas = np.append(thetas, theta)\\n\\tphis = np.append(phis, phi)\\n\\t# print(center, plane, np.median(theta), np.median(phis))\\n\\tCameraPosition['elevation'] = np.median(thetas)\\n\\tCameraPosition['azimuth'] = np.median(phis)\\n\\tif thetas.size > memory:\\n\\t\\tthetas = thetas[1:]\\n\\tif phis.size > memory:\\n\\t\\tphis = phis[1:]\\n\\tf = open(localization_dir + '%d.json' % len(os.listdir(localization_dir)),'w')\\n\\tf.write(json.dumps(CameraPosition))\\n\\tf.close()\\n\\tcenter = apply_camera_orientation(center, CameraPosition)\\n\\tplane = apply_camera_orientation(plane, CameraPosition)\\n\\txyz_arr = apply_camera_matrix_orientation(xyz_arr, CameraPosition)\\n\\treturn xyz_arr, roi_point_cloud, center\",\n \"def random_perm3(data_x, data_y, data_z):\\n data_size = data_y.shape[0]\\n rand_perm = np.arange(data_size)\\n np.random.shuffle(rand_perm)\\n random_data_x = []\\n random_data_z = []\\n for indices in rand_perm: # 'List' object, more complicated !!!\\n random_data_x.append(data_x[indices])\\n random_data_z.append(data_z[indices])\\n # random_data_x = data_x[rand_perm]\\n random_data_y = data_y[rand_perm]\\n # random_data_z = data_z[rand_perm]\\n return random_data_x, random_data_y, random_data_z\",\n \"def random_point():\\n theta = numpy.arccos(2. * numpy.random.random() - 1)\\n phi = 2 * numpy.pi * numpy.random.random()\\n return theta, phi\",\n \"def randomize(self, amplitude):\\n from random import gauss\\n # update alignment from projections\\n self.getMarkersFromTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\\n\\n # add random amplitude\\n # markers\\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\\n for (imark, mark) in enumerate(self._Markers):\\n if (imark + 1) != irefmark:\\n r = mark.get_r()\\n for ii in range(0, 3):\\n r[ii] = gauss(0, amplitude) + r[ii]\\n self._Markers[imark].set_r(r)\\n\\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\\n # translations, rotations, magnifications\\n for itilt in range(0, self._ntilt):\\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\\n if (self._projIndices[itilt] != ireftilt):\\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\\n\\n # update alignment from projections\\n self.setMarkersInTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n R = Rotator.rotation_matrix(alpha,0.0,0.0)\\n return np.dot(R,X)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n\\n beta = np.arccos(1.0-2*random.rand())\\n psi = random.rand() * 2*pi\\n\\n R = Rotator.rotation_matrix(alpha,beta,psi)\\n return np.dot(R,X)\",\n \"def generator(samples, batch_size=32, is_training=True):\\n num_samples = len(samples)\\n\\n #vertical, horizontal range for random translation\\n x_translate_range = 100\\n y_translate_range = 10\\n\\n while 1: # Loop forever so the generator never terminates\\n #shuffle the samples once the whole data is processed into batches\\n shuffle(samples)\\n #split data into batches\\n for offset in range(0, num_samples, batch_size):\\n batch_samples = samples[offset:offset+batch_size]\\n images = []\\n angles = []\\n for batch_sample in batch_samples:\\n # corrections for centered view image, left camera view image and right camera view image\\n corrections = [0,0.2,-0.2]\\n # iterate over center, right and left camera view images\\n for i in range(3):\\n current_path = get_image_path(batch_sample[i])\\n\\n # read image\\n image = cv2.imread(current_path)\\n # append image for training/validation\\n images.append(preprocess(image))\\n\\n # calculate angle measurement with applied angle corrections\\n measurement = float(batch_sample[3]) + corrections[i]\\n angles.append(measurement)\\n\\n # insert flipped image for opposite direction generalization\\n images.append(preprocess(cv2.flip(image, 1)))\\n angles.append(measurement*-1.0)\\n\\n # create random augmented image only for training\\n if is_training:\\n image, measurement = flip_image(image, measurement, flip_probability=0.5)\\n image = add_salt_pepper_noise(image)\\n image, measurement = random_translate(image, measurement, x_translate_range, y_translate_range)\\n image = random_shadow(image)\\n image = random_brightness(image)\\n images.append(preprocess(image))\\n angles.append(measurement)\\n\\n # create X, y dataset\\n X_train = np.array(images)\\n y_train = np.array(angles)\\n\\n yield sklearn.utils.shuffle(X_train, y_train)\",\n \"def __call__(self, results):\\n if np.random.rand() > self.prob:\\n return results\\n h, w = results['image'].shape[:2]\\n center = self.center\\n if center is None:\\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\\n angle = random_negative(self.angle, self.random_negative_prob)\\n self._rotate_img(results, angle, center, self.scale)\\n return results\",\n \"def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\\n def genPos():\\n r = radius_scale * self.np_random.rand() + radius_offset\\n a = -np.pi * angle_scale + angle_offset\\n b = np.pi * angle_scale + angle_offset\\n ang = (b - a) * self.np_random.rand() + a\\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\\n def isNear(pos, poss):\\n for p, o in poss:\\n if np.linalg.norm(p - pos) < near_distance:\\n return True\\n return False\\n def genPosRetry(poss):\\n for i in range(retry):\\n pos = genPos()\\n if not isNear(pos, poss):\\n return pos\\n return genPos()\\n poss = []\\n for i in range(num):\\n pos = genPosRetry(poss)\\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\\n poss.append((pos, orn))\\n self.np_random.shuffle(poss)\\n return poss\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73846465","0.6965289","0.6953168","0.6815348","0.6815157","0.6815157","0.6747695","0.6692255","0.66423446","0.6594938","0.6594938","0.6594938","0.6522628","0.64682126","0.6416248","0.6369285","0.61995316","0.6168288","0.6102223","0.5960313","0.5927957","0.5923554","0.5862046","0.5852015","0.5793729","0.5742075","0.5704654","0.56952965","0.5693704","0.5652093","0.56364","0.56277335","0.56199807","0.5618832","0.5615333","0.5611089","0.56003416","0.5569166","0.5546772","0.5515266","0.5507842","0.5504569","0.54871166","0.5480804","0.5480647","0.54585046","0.54567075","0.5452831","0.5450757","0.545009","0.5445018","0.5427406","0.54112524","0.5399718","0.5396262","0.5394317","0.53912246","0.5390463","0.5371529","0.5370141","0.53543955","0.5351816","0.53475714","0.5338581","0.531655","0.53164506","0.53120047","0.5303012","0.5299852","0.5275566","0.52542025","0.52477825","0.52434844","0.52385503","0.52367026","0.5233778","0.5232877","0.5223458","0.519281","0.5192638","0.51898056","0.51858085","0.5183212","0.5182634","0.5178972","0.5170818","0.5169829","0.5164281","0.51617455","0.5154266","0.5152564","0.5149522","0.51494366","0.5146078","0.5143904","0.5141846","0.5141156","0.5139882"],"string":"[\n \"0.73846465\",\n \"0.6965289\",\n \"0.6953168\",\n \"0.6815348\",\n \"0.6815157\",\n \"0.6815157\",\n \"0.6747695\",\n \"0.6692255\",\n \"0.66423446\",\n \"0.6594938\",\n \"0.6594938\",\n \"0.6594938\",\n \"0.6522628\",\n \"0.64682126\",\n \"0.6416248\",\n \"0.6369285\",\n \"0.61995316\",\n \"0.6168288\",\n \"0.6102223\",\n \"0.5960313\",\n \"0.5927957\",\n \"0.5923554\",\n \"0.5862046\",\n \"0.5852015\",\n \"0.5793729\",\n \"0.5742075\",\n \"0.5704654\",\n \"0.56952965\",\n \"0.5693704\",\n \"0.5652093\",\n \"0.56364\",\n \"0.56277335\",\n \"0.56199807\",\n \"0.5618832\",\n \"0.5615333\",\n \"0.5611089\",\n \"0.56003416\",\n \"0.5569166\",\n \"0.5546772\",\n \"0.5515266\",\n \"0.5507842\",\n \"0.5504569\",\n \"0.54871166\",\n \"0.5480804\",\n \"0.5480647\",\n \"0.54585046\",\n \"0.54567075\",\n \"0.5452831\",\n \"0.5450757\",\n \"0.545009\",\n \"0.5445018\",\n \"0.5427406\",\n \"0.54112524\",\n \"0.5399718\",\n \"0.5396262\",\n \"0.5394317\",\n \"0.53912246\",\n \"0.5390463\",\n \"0.5371529\",\n \"0.5370141\",\n \"0.53543955\",\n \"0.5351816\",\n \"0.53475714\",\n \"0.5338581\",\n \"0.531655\",\n \"0.53164506\",\n \"0.53120047\",\n \"0.5303012\",\n \"0.5299852\",\n \"0.5275566\",\n \"0.52542025\",\n \"0.52477825\",\n \"0.52434844\",\n \"0.52385503\",\n \"0.52367026\",\n \"0.5233778\",\n \"0.5232877\",\n \"0.5223458\",\n \"0.519281\",\n \"0.5192638\",\n \"0.51898056\",\n \"0.51858085\",\n \"0.5183212\",\n \"0.5182634\",\n \"0.5178972\",\n \"0.5170818\",\n \"0.5169829\",\n \"0.5164281\",\n \"0.51617455\",\n \"0.5154266\",\n \"0.5152564\",\n \"0.5149522\",\n \"0.51494366\",\n \"0.5146078\",\n \"0.5143904\",\n \"0.5141846\",\n \"0.5141156\",\n \"0.5139882\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6925797"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":9464,"cells":{"query":{"kind":"string","value":"Randomly rotate the point clouds to augument the dataset rotation is per shape based along up direction"},"document":{"kind":"string","value":"def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data"},"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 rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def random_rotate(self):\r\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\r\n flip = rand.randrange(0, 2, 1) # 0, 1\r\n new_seed = copy.deepcopy(self)\r\n # rotate by 90 degrees * rotation (0, 90, 180 270)\r\n new_seed.cells = np.rot90(new_seed.cells, rotation) \r\n if (flip == 1):\r\n # flip upside down\r\n new_seed.cells = np.flipud(new_seed.cells)\r\n new_seed.xspan = new_seed.cells.shape[0]\r\n new_seed.yspan = new_seed.cells.shape[1]\r\n return new_seed","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k,:,0:3]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def RotatePointCloud(batch_data):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1],])\n return np.dot(batch_data, rotation_matrix)","def rotate_point_cloud_in_plane(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, -sinval, 0],\n [sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\n ## https://en.wikipedia.org/wiki/Rotation_matrix\n if(use_rotation_tensor != True):\n angle_range = DEGREES\n x_angle = radians(random.random() * angle_range)\n y_angle = radians(random.random() * angle_range)\n z_angle = radians(random.random() * angle_range)\n\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\n rotation_matrix = torch.mm(rot_y, rot_z)\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \n\n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n \n \n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\n self.rotation_matrix = rotation_matrix\n \n if(save_rotation_tensor):\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\n else: \n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\n return pointcloud_model_rotated[:,:,0:3]","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n # rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]]) # rotate along y axis\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data, batch_label):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\n return rotated_data, rotated_label","def randomize_trajectory(self):\n self.angle = randint(-360, 360)\n self.speed = randint(1, 5)/2.5","def random_rotation(self, img, p = 0.5):\n if self.decision(p):\n theta = random.randrange(-15, 15)\n phi = random.randrange(-15, 15)\n gamma = random.randrange(-15, 15)\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\n # check if cut is ahve to much dark pixels, more then 20 %\n non_zeros = np.count_nonzero(roi)\n non_zeros_procent = non_zeros / roi.size\n if non_zeros_procent < 0.8:\n pass\n else:\n img = roi\n return img","def _get_random_transform(self, img_shape, seed=None):\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if self.rotation_range:\n theta = np.random.uniform(\n -self.rotation_range,\n self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n try: # 1-D array-like or int\n tx = np.random.choice(self.height_shift_range)\n tx *= np.random.choice([-1, 1])\n except ValueError: # floating point\n tx = np.random.uniform(-self.height_shift_range,\n self.height_shift_range)\n if np.max(self.height_shift_range) < 1:\n tx *= img_shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n try: # 1-D array-like or int\n ty = np.random.choice(self.width_shift_range)\n ty *= np.random.choice([-1, 1])\n except ValueError: # floating point\n ty = np.random.uniform(-self.width_shift_range,\n self.width_shift_range)\n if np.max(self.width_shift_range) < 1:\n ty *= img_shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(\n -self.shear_range,\n self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(\n self.zoom_range[0],\n self.zoom_range[1],\n 2)\n\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\n\n channel_shift_intensity = None\n if self.channel_shift_range != 0:\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\n self.channel_shift_range)\n\n brightness = None\n if self.brightness_range is not None:\n brightness = np.random.uniform(self.brightness_range[0],\n self.brightness_range[1])\n\n transform_parameters = {'theta': theta,\n 'tx': tx,\n 'ty': ty,\n 'shear': shear,\n 'zx': zx,\n 'zy': zy,\n 'flip_horizontal': flip_horizontal,\n 'flip_vertical': flip_vertical,\n 'channel_shift_intensity': channel_shift_intensity,\n 'brightness': brightness}\n\n return transform_parameters","def random_rotation(image, gt, normal=False, random_state=None):\n if random_state is None:\n random_state = np.random.RandomState(None)\n\n degree = int(random_state.normal(0, 10)) if normal else random_state.randint(-10, 10)\n rows, cols = image.shape[:2]\n\n mat = cv2.getRotationMatrix2D((cols / 2, rows / 2), degree, 1)\n result_im = cv2.warpAffine(image, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\n result_gt = cv2.warpAffine(gt, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\n\n return result_im, result_gt","def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\n return rotated_data","def random_rotation(image ):\n random_degree = random.uniform(-25, 25)\n padding_mode = random.sample([\"constant\", \"edge\"], 1)[0]\n return rotate(image, random_degree, mode = padding_mode )","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def random_rotate():\n u = np.random.uniform(size=3)\n\n # Random quaternion\n q = np.array([np.sqrt(1-u[0])*np.sin(2*np.pi*u[1]),\n np.sqrt(1-u[0])*np.cos(2*np.pi*u[1]),\n np.sqrt(u[0])*np.sin(2*np.pi*u[2]),\n np.sqrt(u[0])*np.cos(2*np.pi*u[2])])\n \n # Convert the quaternion into a rotation matrix \n rotMat = np.array([[q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3],\n 2*q[1]*q[2] - 2*q[0]*q[3],\n 2*q[1]*q[3] + 2*q[0]*q[2]],\n [2*q[1]*q[2] + 2*q[0]*q[3],\n q[0]*q[0] - q[1]*q[1] + q[2]*q[2] - q[3]*q[3],\n 2*q[2]*q[3] - 2*q[0]*q[1]],\n [2*q[1]*q[3] - 2*q[0]*q[2],\n 2*q[2]*q[3] + 2*q[0]*q[1],\n q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]]])\n return rotMat","def rotate_point_cloud_by_angle(self, data, rotation_angle):\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n rotated_data = np.dot(data, rotation_matrix)\n\n return rotated_data","def test_d_3():\n rs = 20\n d = 3\n np.random.seed(rs)\n number_rotations = 3\n\n theta_1 = np.random.uniform(0, 2 * math.pi)\n rotation_1 = np.identity(d)\n pos_1 = np.random.randint(0, d - 1)\n pos_2 = np.random.randint(pos_1 + 1, d)\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\n\n theta_2 = np.random.uniform(0, 2 * math.pi)\n rotation_2 = np.identity(d)\n pos_3 = np.random.randint(0, d - 1)\n pos_4 = np.random.randint(pos_3 + 1, d)\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\n\n theta_3 = np.random.uniform(0, 2 * math.pi)\n rotation_3 = np.identity(d)\n pos_5 = np.random.randint(0, d - 1)\n pos_6 = np.random.randint(pos_5 + 1, d)\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\n\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\n np.random.seed(rs)\n rotation_function = (mt_obj.calculate_rotation_matrix\n (d, number_rotations))\n assert(np.all(final_rotation == rotation_function))","def augument_data(data_dir, center, left, right, steering_angle):\n image, steering_angle = choose_random_image(data_dir, center, left, right, steering_angle)\n # Randomly flipt the image horizontally and adjust the steering angle.\n if np.random.rand() < 0.5:\n image = cv2.flip(image, 1)\n steering_angle = -steering_angle\n \n #translate the object with random distance in x and y direction and adjust the steering angle\n trans_x = np.random.uniform(0, 30)\n trans_y = np.random.uniform(0, 20)\n steering_angle += trans_x * 0.002\n trans_matrix = np.float32([[1, 0, trans_x], [0, 1, trans_y]])\n height= image.shape[0]\n width=image.shape[1]\n image = cv2.warpAffine(image, trans_matrix, (width, height))\n return image, steering_angle","def test_rotating_phantom(self):\n cheese = TomoCheese.from_demo_images()\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\n for img in cheese.dicom_stack:\n img.array = rotate(img.array, angle=3, mode=\"edge\")\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)","def random_rotation_matrix():\n\n x = np.random.uniform(size=3)\n theta = x[0]*2*math.pi\n phi = x[1]*2*math.pi\n z = x[2]*2\n\n r = math.sqrt(z)\n vx = math.sin(phi)*r\n vy = math.cos(phi)*r\n vz = math.sqrt(2.0-z)\n\n st = math.sin(theta)\n ct = math.cos(theta)\n\n sx = vx*ct-vy*st\n sy = vx*st+vy*ct\n\n return np.array([[vx*sx-ct, vx*sy-st, vx*vz],\n [vy*sx+st, vy*sy-ct, vy*vz],\n [vz*sx,vz*sy,1.0-z]])","def random_rotation_2d(batch, max_angle):\n size = batch.shape\n batch = np.squeeze(batch)\n batch_rot = np.zeros(batch.shape)\n for i in range(batch.shape[0]):\n if bool(random.getrandbits(1)):\n image = np.squeeze(batch[i])\n angle = random.uniform(-max_angle, max_angle)\n batch_rot[i] = scipy.ndimage.interpolation.rotate(image, angle, mode='nearest', reshape=False)\n else:\n batch_rot[i] = batch[i]\n return batch_rot.reshape(size)","def _rotate(self):\n new_points = list()\n for i in range(len(self._points)):\n x = self._points[i][0]\n y = self._points[i][1]\n new_x = self._center[0] + self._center[1] - y\n new_y = self._center[1] - self._center[0] + x\n new_points.append((new_x, new_y))\n return new_points","def random_rotation(x, rg, row_axis=0, col_axis=1, channel_axis=2,\n fill_mode='nearest', cval=0., interpolation_order=1):\n theta = np.random.uniform(-rg, rg)\n x = apply_affine_transform(x, theta=theta, channel_axis=channel_axis,\n fill_mode=fill_mode, cval=cval,\n order=interpolation_order)\n return x","def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n shape_pc = batch_data[k, ...]\n rotation_matrix = rotation_matrices[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def Generate_Random( self ):\n print( 'Generating Random coordinates' )\n stands = self.Data.Stand.keys()\n stands.sort()\n for s in stands:\n trees = self.Data.Stand[s].Tree.keys()\n trees.sort()\n for t in trees:\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )","def rotate(self,X):\n alpha = random.rand() * 2*pi\n beta = self.beta_sample()\n R = Rotator.rotation_matrix(alpha,beta,0.0)\n X = np.dot(R, X)\n if self.random_flip and (random.rand() > 0.5):\n X[2,:] = -X[2,:]\n X[1,:] = -X[1,:]\n return X","def generate_random_DC_MT():\n # Specify DC moment tensor to rotate:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n # And rotate DC moment tensor by random 3D angle:\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\n # And normallise so that moment tensor magnitude = 1:\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\n return random_DC_six_MT_normalised","def rotate_random(tile):\n return rotate(tile, random.choice([0, 1, 2, 3]))","def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\n return rotated_data","def image_rotate(Xb, batch_size):\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\n delta = 30. * intensity # scale by self.intensity\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\n return Xb","def rotate_augmentation():\n rand_rotate = np.random.randint(180)\n return lambda image: rotate_with_extension(image, rand_rotate)","def augment_cloud(Ps):\n \"Augmented params:\"\n pc_augm_scale=0\n pc_augm_rot=1\n pc_augm_mirror_prob=0.5\n pc_augm_jitter=0\n\n M = transforms3d.zooms.zfdir2mat(1)\n if pc_augm_scale > 1:\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\n if pc_augm_rot:\n angle = random.uniform(0, 2*math.pi)\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\n result = []\n for P in Ps:\n P[:,:3] = np.dot(P[:,:3], M.T)\n\n if pc_augm_jitter:\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\n result.append(P)\n return result","def randomizePlayerPose(transform, arena_radius=8):\n initial_r = arena_radius * random.random()\n initial_theta = 2 * math.pi * random.random()\n initial_x = initial_r * math.cos(initial_theta)\n initial_y = initial_r * math.sin(initial_theta)\n initial_rotation = 2 * math.pi * random.random()\n transform.translation.x = initial_x\n transform.translation.y = initial_y\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])","def rotate(self, z_dim=False):\n self.x_displacement = np.format_float_scientific(\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\n )\n self.y_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\n )\n zd = z_dim\n if zd == True:\n self.z_angle = random.uniform(1, 180)\n self.z_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\n )\n else:\n self.z_displacement = 0\n self.z_angle = 0\n return [self.x_displacement, self.y_displacement, self.z_displacement]","def test_rot(self):\n\n print(\"rot()\")\n obs = self.fixture\n\n # rotation(0) = identity\n for axis in [1, 2, 3]:\n # theta = 0.0\n rotation = obs.rot(0.0, axis)\n # find || eye - rot1 ||\n diff = np.linalg.norm(np.eye(3) - rotation)\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\n # theta = 2*pi\n rotation = obs.rot(2.0 * np.pi, axis)\n # find || eye - rot1 ||\n diff = np.linalg.norm(np.eye(3) - rotation)\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\n\n # perform many randomized tests\n num_tests = 100\n num_products = 10\n for _test_counter in range(num_tests):\n thetas = []\n axes = []\n base = np.eye(3)\n # we will multiply a series of rotations into \"base\"\n rot_all = base\n for _rot_counter in range(num_products):\n theta = np.random.uniform(2 * np.pi) # in [0,2 pi]\n axis = np.random.randint(3) + 1 # in {1,2,3}\n axes.append(axis)\n thetas.append(theta)\n rotation = obs.rot(theta, axis)\n # multiply rot1 into the cumulative rotation\n rot_all = np.dot(rot_all, rotation)\n # now, back all the rotations out\n for _rot_counter in range(num_products):\n theta = thetas.pop()\n axis = axes.pop()\n # apply the inverse rotation\n rotation = obs.rot(-theta, axis)\n rot_all = np.dot(rot_all, rotation)\n # find || base - rot1 * rot2 ||\n diff = np.linalg.norm(base - rot_all)\n self.assertAlmostEqual(diff, 0.0, delta=1e-10 * num_products)","def generate_random_rot():\n from pyso3.quaternion import quat2rot\n import numpy as np\n q = np.random.randn(4)\n q = q / np.linalg.norm(q)\n return quat2rot(q)","def generate(self):\n inside = self.crystal.is_inside(self.x,self.y,self.z)\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\n return self.rot.rotate(X)","def random_rotation(x, rg, row_axis=1, col_axis=2, channel_axis=0,\n fill_mode='nearest', cval=0.):\n theta = np.pi / 180 * np.random.uniform(-rg, rg)\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n\n h, w = x.shape[row_axis], x.shape[col_axis]\n transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\n return x","def RotateCopyPlanes(tot_ang,count,init_planes,dir_vec):\n if isinstance(init_planes,Rhino.Geometry.Plane): init_planes=[init_planes]\n inc=tot_ang/(count-1)\n origin=Rhino.Geometry.Point3d(0,0,0)\n planes=[]\n objs=[]\n for i in range(count):\n for init_plane in init_planes:\n new_plane=Rhino.Geometry.Plane(init_plane)\n new_plane.Rotate(inc*i,dir_vec,origin)\n planes.append(new_plane)\n return planes","def rotate_img(img, random):\n degrees = 45 * (random - 0.5)\n h, w = (int(2 * i / 3) for i in img.shape[:2])\n img = imutils.rotate_bound(img, degrees)\n h2, w2 = img.shape[:2]\n x = int((w2 - w) / 2)\n y = int((h2 - h) / 2)\n img = img[y:y + h, x:x + w]\n return img","def spread_quaternions(points,num=100,quats_per_step=100):\n quats = np.zeros((num,4))\n rot_points = np.zeros((num,points.shape[0],3))\n quats[0,:] = [0,0,0,1]\n rot_points[0,:,:] = points\n for ix in range(1,num):\n rand_quats = random_quaternions(quats_per_step) \n positioned = rotate_points(points,rand_quats) \n dists = point_dists(rot_points[:ix],positioned)\n new_rot = np.argmax(dists) \n quats[ix,:]=rand_quats[new_rot,:]\n rot_points[ix,:,:] = positioned[new_rot,:,:]\n \n return quats,rot_points","def shuffle(self):\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\n perm = np.random.permutation(self.X_data.shape[0])\n for old_idx, new_idx in enumerate(perm):\n new_X[new_idx] = self.X_data[old_idx]\n new_Y[new_idx] = self.Y_data[old_idx]\n self.X_data = new_X\n self.Y_data = new_Y","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def random_translation(canvas, img):","def rotate(im: Image) -> Image:\n return im.rotate(random.randint(0, 360))","def rotate_array_deterministic(data):\n return np.concatenate(\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)","def mutate_point_poly3(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def rotate_shape(shape, xy_center, angle_degrees):","def randomize(data):\r\n permutation = np.random.permutation(data.shape[0])\r\n shuffled_data = data[permutation, :]\r\n # shuffled_y = y[permutation]\r\n return shuffled_data","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def random_transform(rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask, rdrs_contains_month=False, border_masking=0, p=0.5):\n if random.random() < p:\n angle = random.randint(-180, 180)\n horizontal_flip = random.choice([True, False])\n vertical_flip = random.choice([True, False])\n transformed_tensors = []\n for tensor in [rdrs_batch, geophysical_batch, y_batch, y_means, train_mask.float(), val_mask.float()]:\n images = [TF.to_pil_image(image, mode='F') for image in tensor.reshape((-1,*tensor.shape[-2:]))]\n images = [TF.rotate(image, angle) for image in images]\n images = [TF.hflip(image) for image in images] if horizontal_flip else images\n images = [TF.vflip(image) for image in images] if vertical_flip else images\n \n transformed_tensors.append(torch.cat([TF.to_tensor(image) for image in images]).reshape(tensor.shape))\n \n rdrs_transformed, geophysical_transformed, y_transformed, \\\n y_means_transformed, train_mask_transformed, val_mask_transformed = transformed_tensors\n \n # Fix \"month\" features that are all-0/all-1 images\n if rdrs_contains_month:\n rdrs_transformed[:,:,-12:] = rdrs_batch[:,:,-12:]\n \n # Do not consider subbasins that are rotated almost out of the image for training\n border_mask = torch.zeros(train_mask.shape, dtype=torch.bool)\n border_mask[border_masking:-border_masking,border_masking:-border_masking] = True\n return rdrs_transformed, geophysical_transformed, y_transformed, y_means_transformed, \\\n train_mask_transformed.bool() & border_mask, val_mask_transformed.bool() & border_mask\n \n return rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask","def rotate_3dcloud(cloud):\n theta = np.radians(90)\n c, s = np.cos(theta), np.sin(theta)\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\n return cloud.dot(Rx.T)","def rotate_crossover(population):\r\n global chromosome_length\r\n global decryption_key\r\n\r\n new_population = []\r\n\r\n decryption_key += rotate_crossover_del\r\n\r\n # predefined rotation value, varied every round\r\n rotation_offset = random.randint(1, chromosome_length)\r\n\r\n decryption_key += rotation_offset_del + str(rotation_offset) + rotation_offset_del\r\n\r\n decryption_key += rotation_types_del\r\n\r\n for chromosome in population:\r\n\r\n p = random.uniform(0, 1)\r\n\r\n if p > 0.5:\r\n decryption_key += \"right|\"\r\n right_first = chromosome[0: len(chromosome) - rotation_offset]\r\n right_second = chromosome[len(chromosome) - rotation_offset:]\r\n new_population.append(right_second + right_first)\r\n else:\r\n decryption_key += \"left|\"\r\n left_first = chromosome[0: rotation_offset]\r\n left_second = chromosome[rotation_offset:]\r\n new_population.append(left_second + left_first)\r\n\r\n decryption_key += rotation_types_del\r\n\r\n decryption_key += rotate_crossover_del\r\n\r\n return new_population","def reset(self):\n self.x = random.uniform(-0.05, 0.05)\n self.x_dot = random.uniform(-0.05, 0.05)\n self.theta = random.uniform(-0.05, 0.05)\n self.theta_dot = random.uniform(-0.05, 0.05)","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def __randomize_data(self):\n times = map(lambda (t, _): t, self.data)\n coords = map(lambda (_, c): c, self.data)\n return zip(times, map(DataGen.__randomize_coord, coords))","def test_rotate_up(self):\n # Testing 'up' rotation clockwise\n side = 'U'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def rotation3(size=None): # noqa\n if size is None:\n size = ()\n else:\n try:\n size = tuple(size)\n except TypeError:\n size = (size,)\n theta, phi, z = 2. * random((3, 1) + size)\n theta *= pi # Initial rotation angle about z-axis.\n phi *= pi # Angle in xy plane for tilt of z-axis.\n # Magnitude of tilt is random variable z.\n r = sqrt(z)\n v = concatenate((r*sin(phi), r*cos(phi), sqrt(2.-z)))\n st, ct = sin(theta), cos(theta)\n s = concatenate((v[0]*ct - v[1]*st, v[0]*st + v[1]*ct))\n m = v[:, newaxis].repeat(3, axis=1)\n m[:, :2] *= s\n m[0, :2] -= concatenate((ct, st))\n m[1, :2] += concatenate((st, -ct))\n m[:2, 2] *= v[2]\n m[2, 2] = 1. - z # Equals v[2]*v[2] - 1.\n if m.ndim > 2:\n m = transpose(m, roll(range(m.ndim), -2)).copy()\n return m","def random_transform_extension(self, x, y, seed=None):\n # x is a single image, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n # use composition of homographies\n # to generate final transform that needs to be applied\n if self.rotation_range:\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(-self.shear_range, self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\n\n transform_matrix = None\n if theta != 0:\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n transform_matrix = rotation_matrix\n\n if tx != 0 or ty != 0:\n shift_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\n\n if shear != 0:\n shear_matrix = np.array([[1, -np.sin(shear), 0],\n [0, np.cos(shear), 0],\n [0, 0, 1]])\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\n\n if zx != 1 or zy != 1:\n zoom_matrix = np.array([[zx, 0, 0],\n [0, zy, 0],\n [0, 0, 1]])\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\n\n if transform_matrix is not None:\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n if self.channel_shift_range != 0:\n x = image.random_channel_shift(x,\n self.channel_shift_range,\n img_channel_axis)\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_col_axis)\n y = kimage.flip_axis(y, img_col_axis)\n\n if self.vertical_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_row_axis)\n y = kimage.flip_axis(y, img_row_axis)\n return x, y","def random_transpose(pianoroll):\n semitone = np.random.randint(-5, 6)\n if semitone > 0:\n pianoroll[:, semitone:, 1:] = pianoroll[:, :-semitone, 1:]\n pianoroll[:, :semitone, 1:] = 0\n elif semitone < 0:\n pianoroll[:, :semitone, 1:] = pianoroll[:, -semitone:, 1:]\n pianoroll[:, semitone:, 1:] = 0\n return pianoroll","def generate_random_MT_Lune_samp():\n # 1. Get randomly varied Lune parameters (gamma and delta):\n # Define U rotation matrix (See Tape and Tape 2012/2013):\n U_rot_matrix = (1./np.sqrt(6))*np.vstack(([np.sqrt(3.),0.,-np.sqrt(3.)],[-1.,2.,-1.], [np.sqrt(2.),np.sqrt(2.),np.sqrt(2.)]))\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random delta and gamma Lune angles:\n delta = np.random.uniform(-np.pi/2., np.pi/2.) # theta, but shifted to range between -pi/2 and pi/2 (See Tape and Tape 2012/2013)\n beta = (np.pi/2.) - delta # Beta is simply phase shift of delta (See Tape and Tape 2012/2013)\n gamma = np.random.uniform(-np.pi/6., np.pi/6.) # phi, but shifted to range between -pi/6 and pi/6 (See Tape and Tape 2012/2013)\n # Get eigenvalues from delta,gamma,beta:\n lune_space_uvw_vec = np.vstack(([np.cos(gamma)*np.sin(beta)], [np.sin(gamma)*np.sin(beta)], [np.cos(beta)]))\n lambda_vec = np.dot(np.transpose(U_rot_matrix), lune_space_uvw_vec) # (See Tape and Tape 2012, eq. 20)\n Lune_space_MT = np.vstack(([lambda_vec[0],0.,0.],[0.,lambda_vec[1],0.], [0.,0.,lambda_vec[2]])) # MT with principle axes in u,v,w Lune space\n # 2. Get theta and phi angles to rotate Lune_space_MT by to randomly rotate into x,y,z space:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z)\n phi = np.arctan2(y,x)\n # 3. Rotate Lune_space_MT from u,v,w coords to x,y,z coords:\n random_MT = rot_mt_by_theta_phi(Lune_space_MT, theta, phi)\n random_six_MT = get_six_MT_from_full_MT_array(random_MT)\n # And normallise so that moment tensor magnitude = 1:\n random_six_MT_normalised = random_six_MT/((np.sum(random_six_MT**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n random_six_MT_normalised = np.reshape(random_six_MT_normalised, (6, 1))\n return random_six_MT_normalised","def test_transform_3d(transform, alpha = 1):\r\n points = 20*[None]\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n points[i] = vec3(x, y, z)\r\n tr_x = random.randrange(-40, 41)\r\n tr_y = random.randrange(-40, 41)\r\n tr_z = random.randrange(-40, 41)\r\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\r\n print(\"Translation\")\r\n print(\"Input\".ljust(30), \"Translation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n th_x = 2*math.pi*random.random()\r\n th_y = 2*math.pi*random.random()\r\n th_z = 2*math.pi*random.random()\r\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\r\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\r\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\r\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\r\n print(\"Rotation\")\r\n print(\"Input\".ljust(30), \"Rotation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\r\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\r\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k = math.exp(2*random.random() - 1)\r\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\r\n print(\"Uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k*x, k*y, k*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k_x = math.exp(2*random.random() - 1)\r\n k_y = 3*random.random() + 1\r\n k_z = 3*random.random() + 1\r\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\r\n else: k_y = k_x + k_y\r\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\r\n else: k_z = (k_x + k_y)/2 + k_z\r\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\r\n print(\"Non-uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()","def mutate_point_circ(mutated_genome):\n seed = random.randint(0,3)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_circ(mutated_genome,index)\n elif seed == 1:\n shift_point_circ(mutated_genome,index)\n elif seed == 2:\n move_radius_circ(mutated_genome,index)\n else: #seed == 3:\n shift_radius_circ(mutated_genome,index)","def rotate_points(points, rot):\n t0 = time.time()\n points_rot = points.transpose()\n points_rot = rot @ points_rot\n points_rot = points_rot.transpose()\n # print(f\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\")\n return points_rot","def generate_random_DC_single_force_coupled_tensor():\n # 1. --- Specify DC moment tensor to rotate ---:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # 2. --- Specify single force 3-vector in same direction as slip of DC solution ---:\n NED_single_force_vector_to_rotate = np.array([1.,0.,0.], dtype=float)\n # 3. --- Rotate DC moment tensor and single force by same random rotation on sphere:\n # 3.a. Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n # 3.b. Rotate DC moment tensor by random 3D angle:\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5) # And normallise so that moment tensor magnitude = 1\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1)) # And set to correct dimensions (so matrix multiplication in forward model works correctly)\n # 3.c. Rotate Single force 3-vector by the same random 3D angle:\n random_coupled_NED_single_force = rot_single_force_by_theta_phi(NED_single_force_vector_to_rotate, theta, phi)\n random_coupled_single_force = np.array([random_coupled_NED_single_force[1], random_coupled_NED_single_force[0], random_coupled_NED_single_force[2]]) # Convert single force from NED coords to END coords (as that is what greens functions are in)\n random_coupled_single_force = np.reshape(random_coupled_single_force, (3, 1))\n # 4. --- Get random fraction amplitude DC and single force components (sum of amplitudes is to 1) ---:\n random_amp_frac = random.random() # random number between 0. and 1.\n random_DC_six_MT_normalised = random_DC_six_MT_normalised*random_amp_frac\n random_coupled_single_force = random_coupled_single_force*(1.-random_amp_frac)\n # 5. --- Finally combine to tensor of length 9 ---:\n random_DC_single_force_coupled_tensor = np.vstack((random_DC_six_MT_normalised, random_coupled_single_force))\n return random_DC_single_force_coupled_tensor, random_amp_frac","def rotateZ(self, *args, **kwargs):\n ...","def sample_direction():\r\n gamma = random.random()\r\n mu = 2*gamma-1\r\n gamma = random.random()\r\n phi = 2*np.pi*gamma\r\n direction = [np.sqrt(1-mu**2)*np.cos(phi), np.sqrt(1-mu**2)*np.sin(phi), mu]\r\n return direction","def _random_permutation(self):\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))","def random_params_gen(self) -> TransformParams:\n while True:\n do_hor_flip = self.horizontal_flip and (np.random.random() < 0.5)\n do_vert_flip = self.vertical_flip and (np.random.random() < 0.5)\n\n yield TransformParams(do_hor_flip=do_hor_flip,\n do_vert_flip=do_vert_flip)","def repick(g1_x, g1_y, g1_z):\n i = random.randint(0, len(g1_x) - 1)\n x = g1_x[i]\n y = g1_y[i]\n z = g1_z[i]\n return x, y, z","def mutate_point_trig(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_trig(mutated_genome,index)\n else: #seed == 1:\n shift_point_trig(mutated_genome,index)","def randomcorners():\n r = lambda x: random.randint(int(x*0.4), int(x*0.6))\n cx = r(gs.DEFAULTS['width'])\n cy = r(gs.DEFAULTS['height'])\n\n w = int(gs.DEFAULTS['width'] * random.random() * 0.2)\n h = int(gs.DEFAULTS['height'] * random.random() * 0.2)\n\n rcrns = [(cx-w, cy-h), (cx+w, cy-h), (cx+w, cy+h), (cx-w, cy+h)]\n random.shuffle(rcrns)\n\n return rcrns","def rotate_points(points,quaternions):\n \n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \n res[:,:,1:] = points \n conjugates = conjugate(quaternions) \n \n for ix in range(len(points)):\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\n return res[:,:,1:]","def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\n # get a random angle\n angle = np.random.randint(0, self.rotate)\n # get a random sign for the angle\n sign = np.random.randint(0, 2)\n x = rotate(x, -sign * angle, reshape=False)\n m = rotate(m, -sign * angle, axes=(0, 1),\n mode='nearest',\n reshape=False)\n return x, m","def test_random_transform():\n # given\n train = pd.read_csv('source/train.csv')\n train['labels'] = train['labels'].map(ast.literal_eval)\n image_path = os.path.join('source', train.iloc[0].path)\n all_labels = train.iloc[0]['labels']\n for label in all_labels:\n if label['class'] == 'whiteboard':\n break\n xn = [int(float(x)) for x in label['xn'].split(';')][:4]\n yn = [int(float(y)) for y in label['yn'].split(';')][:4]\n labels = np.zeros((4, 2))\n for i in range(4):\n labels[i, 0] = xn[i]\n labels[i, 1] = yn[i]\n img = cv2.imread(image_path)\n kw = dict(rotation_range=15,\n height_shift_range=0.2,\n width_shift_range=0.2,\n shear_range=0.3,\n channel_shift_range=0.2,\n horizontal_flip=True,\n vertical_flip=True,\n dim_ordering='tf',\n seed=1313)\n # when\n rimg, rlabels = image_generator.random_transform(img, labels, **kw)\n\n # then just assert transformation isn't changed much\n assert MultiPoint([[224.91875347, 58.05657097],\n [673.57648317, 189.27244333],\n [544.23308452, 381.12743459],\n [70.73339963, 312.7359806]]\n ).equals_exact(rlabels, 5)","def generate_random_DC_crack_coupled_tensor():\n # 1. Generate random DC MT and crack MT:\n # generate DC MT:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\n # Get between small range:\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\n random_num = random.random()\n if random_num <= 0.5:\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\n elif random_num > 0.5:\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n # And redistribute evenly everywhere on boundary:\n random_num = random.random()\n if random_num>0.25 and random_num<=0.5:\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\n if random_num>0.5 and random_num<=0.75:\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\n if random_num>0.75 and random_num<=1.0:\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\n # --- ---\n # random_num = random.random()\n # if random_num <= 0.5:\n # theta_lune_sphere = random.random()*np.pi/2.\n # elif random_num > 0.5:\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\n # random_num = random.random()\n # if random_num <= 0.5:\n # phi_lune_sphere = np.pi/6.\n # elif random_num > 0.5:\n # phi_lune_sphere = -1.*np.pi/6.\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\n # 2. Combine DC and crack tensors:\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\n # 3. Randomly rotate DC-crack MT to random orientation:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\n # 4. Normalise and get 6 MT:\n # Get 6 MT:\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\n # And normallise so that moment tensor magnitude = 1:\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\n return DC_crack_six_MT_rotated_normalised, random_amp_frac","def rotateZ(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n x = self.x * cosa - self.y * sina\r\n y = self.x * sina + self.y * cosa\r\n return Point3D(x, y, self.z)","def orient_point_cloud_to_ground_plane(xyz_arr, roi_point_cloud, thetas, phis, num_points, num_planes, memory):\n\tcenter, plane, phi, theta = get_orientation(roi_point_cloud, num_points, num_planes)\n\tthetas = np.append(thetas, theta)\n\tphis = np.append(phis, phi)\n\t# print(center, plane, np.median(theta), np.median(phis))\n\tCameraPosition['elevation'] = np.median(thetas)\n\tCameraPosition['azimuth'] = np.median(phis)\n\tif thetas.size > memory:\n\t\tthetas = thetas[1:]\n\tif phis.size > memory:\n\t\tphis = phis[1:]\n\tf = open(localization_dir + '%d.json' % len(os.listdir(localization_dir)),'w')\n\tf.write(json.dumps(CameraPosition))\n\tf.close()\n\tcenter = apply_camera_orientation(center, CameraPosition)\n\tplane = apply_camera_orientation(plane, CameraPosition)\n\txyz_arr = apply_camera_matrix_orientation(xyz_arr, CameraPosition)\n\treturn xyz_arr, roi_point_cloud, center","def random_perm3(data_x, data_y, data_z):\n data_size = data_y.shape[0]\n rand_perm = np.arange(data_size)\n np.random.shuffle(rand_perm)\n random_data_x = []\n random_data_z = []\n for indices in rand_perm: # 'List' object, more complicated !!!\n random_data_x.append(data_x[indices])\n random_data_z.append(data_z[indices])\n # random_data_x = data_x[rand_perm]\n random_data_y = data_y[rand_perm]\n # random_data_z = data_z[rand_perm]\n return random_data_x, random_data_y, random_data_z","def random_point():\n theta = numpy.arccos(2. * numpy.random.random() - 1)\n phi = 2 * numpy.pi * numpy.random.random()\n return theta, phi","def randomize(self, amplitude):\n from random import gauss\n # update alignment from projections\n self.getMarkersFromTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\n\n # add random amplitude\n # markers\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\n for (imark, mark) in enumerate(self._Markers):\n if (imark + 1) != irefmark:\n r = mark.get_r()\n for ii in range(0, 3):\n r[ii] = gauss(0, amplitude) + r[ii]\n self._Markers[imark].set_r(r)\n\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\n # translations, rotations, magnifications\n for itilt in range(0, self._ntilt):\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\n if (self._projIndices[itilt] != ireftilt):\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\n\n # update alignment from projections\n self.setMarkersInTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n R = Rotator.rotation_matrix(alpha,0.0,0.0)\n return np.dot(R,X)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n\n beta = np.arccos(1.0-2*random.rand())\n psi = random.rand() * 2*pi\n\n R = Rotator.rotation_matrix(alpha,beta,psi)\n return np.dot(R,X)","def generator(samples, batch_size=32, is_training=True):\n num_samples = len(samples)\n\n #vertical, horizontal range for random translation\n x_translate_range = 100\n y_translate_range = 10\n\n while 1: # Loop forever so the generator never terminates\n #shuffle the samples once the whole data is processed into batches\n shuffle(samples)\n #split data into batches\n for offset in range(0, num_samples, batch_size):\n batch_samples = samples[offset:offset+batch_size]\n images = []\n angles = []\n for batch_sample in batch_samples:\n # corrections for centered view image, left camera view image and right camera view image\n corrections = [0,0.2,-0.2]\n # iterate over center, right and left camera view images\n for i in range(3):\n current_path = get_image_path(batch_sample[i])\n\n # read image\n image = cv2.imread(current_path)\n # append image for training/validation\n images.append(preprocess(image))\n\n # calculate angle measurement with applied angle corrections\n measurement = float(batch_sample[3]) + corrections[i]\n angles.append(measurement)\n\n # insert flipped image for opposite direction generalization\n images.append(preprocess(cv2.flip(image, 1)))\n angles.append(measurement*-1.0)\n\n # create random augmented image only for training\n if is_training:\n image, measurement = flip_image(image, measurement, flip_probability=0.5)\n image = add_salt_pepper_noise(image)\n image, measurement = random_translate(image, measurement, x_translate_range, y_translate_range)\n image = random_shadow(image)\n image = random_brightness(image)\n images.append(preprocess(image))\n angles.append(measurement)\n\n # create X, y dataset\n X_train = np.array(images)\n y_train = np.array(angles)\n\n yield sklearn.utils.shuffle(X_train, y_train)","def __call__(self, results):\n if np.random.rand() > self.prob:\n return results\n h, w = results['image'].shape[:2]\n center = self.center\n if center is None:\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\n angle = random_negative(self.angle, self.random_negative_prob)\n self._rotate_img(results, angle, center, self.scale)\n return results","def shift(self):\n \"\"\"\n shift cluster randomly within bounds of im\n \"\"\"\n r = self.std\n mid = self.mid_pixel #center pixel index of 384x384 image\n delta = self.im_size - self.mid_pixel - r - 10\n \n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n\n self.x += x\n self.y += y\n im_shift = np.roll(self.im,shift=y,axis=0)\n self.im = np.roll(im_shift,shift=x,axis=1)\n \n return"],"string":"[\n \"def rotate_point_cloud(data):\\n rotated_data = np.zeros(data.shape, dtype=np.float32)\\n for k in xrange(data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def random_rotate(self):\\r\\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\\r\\n flip = rand.randrange(0, 2, 1) # 0, 1\\r\\n new_seed = copy.deepcopy(self)\\r\\n # rotate by 90 degrees * rotation (0, 90, 180 270)\\r\\n new_seed.cells = np.rot90(new_seed.cells, rotation) \\r\\n if (flip == 1):\\r\\n # flip upside down\\r\\n new_seed.cells = np.flipud(new_seed.cells)\\r\\n new_seed.xspan = new_seed.cells.shape[0]\\r\\n new_seed.yspan = new_seed.cells.shape[1]\\r\\n return new_seed\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k,:,0:3]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def RotatePointCloud(batch_data):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1],])\\n return np.dot(batch_data, rotation_matrix)\",\n \"def rotate_point_cloud_in_plane(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, -sinval, 0],\\n [sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\\n ## https://en.wikipedia.org/wiki/Rotation_matrix\\n if(use_rotation_tensor != True):\\n angle_range = DEGREES\\n x_angle = radians(random.random() * angle_range)\\n y_angle = radians(random.random() * angle_range)\\n z_angle = radians(random.random() * angle_range)\\n\\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\\n rotation_matrix = torch.mm(rot_y, rot_z)\\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \\n\\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n \\n \\n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\\n self.rotation_matrix = rotation_matrix\\n \\n if(save_rotation_tensor):\\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \\n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\\n else: \\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\\n return pointcloud_model_rotated[:,:,0:3]\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n # rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]]) # rotate along y axis\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data, batch_label):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\\n return rotated_data, rotated_label\",\n \"def randomize_trajectory(self):\\n self.angle = randint(-360, 360)\\n self.speed = randint(1, 5)/2.5\",\n \"def random_rotation(self, img, p = 0.5):\\n if self.decision(p):\\n theta = random.randrange(-15, 15)\\n phi = random.randrange(-15, 15)\\n gamma = random.randrange(-15, 15)\\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\\n # check if cut is ahve to much dark pixels, more then 20 %\\n non_zeros = np.count_nonzero(roi)\\n non_zeros_procent = non_zeros / roi.size\\n if non_zeros_procent < 0.8:\\n pass\\n else:\\n img = roi\\n return img\",\n \"def _get_random_transform(self, img_shape, seed=None):\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if self.rotation_range:\\n theta = np.random.uniform(\\n -self.rotation_range,\\n self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n try: # 1-D array-like or int\\n tx = np.random.choice(self.height_shift_range)\\n tx *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n tx = np.random.uniform(-self.height_shift_range,\\n self.height_shift_range)\\n if np.max(self.height_shift_range) < 1:\\n tx *= img_shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n try: # 1-D array-like or int\\n ty = np.random.choice(self.width_shift_range)\\n ty *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n ty = np.random.uniform(-self.width_shift_range,\\n self.width_shift_range)\\n if np.max(self.width_shift_range) < 1:\\n ty *= img_shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(\\n -self.shear_range,\\n self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(\\n self.zoom_range[0],\\n self.zoom_range[1],\\n 2)\\n\\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\\n\\n channel_shift_intensity = None\\n if self.channel_shift_range != 0:\\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\\n self.channel_shift_range)\\n\\n brightness = None\\n if self.brightness_range is not None:\\n brightness = np.random.uniform(self.brightness_range[0],\\n self.brightness_range[1])\\n\\n transform_parameters = {'theta': theta,\\n 'tx': tx,\\n 'ty': ty,\\n 'shear': shear,\\n 'zx': zx,\\n 'zy': zy,\\n 'flip_horizontal': flip_horizontal,\\n 'flip_vertical': flip_vertical,\\n 'channel_shift_intensity': channel_shift_intensity,\\n 'brightness': brightness}\\n\\n return transform_parameters\",\n \"def random_rotation(image, gt, normal=False, random_state=None):\\n if random_state is None:\\n random_state = np.random.RandomState(None)\\n\\n degree = int(random_state.normal(0, 10)) if normal else random_state.randint(-10, 10)\\n rows, cols = image.shape[:2]\\n\\n mat = cv2.getRotationMatrix2D((cols / 2, rows / 2), degree, 1)\\n result_im = cv2.warpAffine(image, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\\n result_gt = cv2.warpAffine(gt, mat, (cols, rows), flags=cv2.INTER_NEAREST, borderMode=cv2.BORDER_REFLECT)\\n\\n return result_im, result_gt\",\n \"def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def random_rotation(image ):\\n random_degree = random.uniform(-25, 25)\\n padding_mode = random.sample([\\\"constant\\\", \\\"edge\\\"], 1)[0]\\n return rotate(image, random_degree, mode = padding_mode )\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def random_rotate():\\n u = np.random.uniform(size=3)\\n\\n # Random quaternion\\n q = np.array([np.sqrt(1-u[0])*np.sin(2*np.pi*u[1]),\\n np.sqrt(1-u[0])*np.cos(2*np.pi*u[1]),\\n np.sqrt(u[0])*np.sin(2*np.pi*u[2]),\\n np.sqrt(u[0])*np.cos(2*np.pi*u[2])])\\n \\n # Convert the quaternion into a rotation matrix \\n rotMat = np.array([[q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3],\\n 2*q[1]*q[2] - 2*q[0]*q[3],\\n 2*q[1]*q[3] + 2*q[0]*q[2]],\\n [2*q[1]*q[2] + 2*q[0]*q[3],\\n q[0]*q[0] - q[1]*q[1] + q[2]*q[2] - q[3]*q[3],\\n 2*q[2]*q[3] - 2*q[0]*q[1]],\\n [2*q[1]*q[3] - 2*q[0]*q[2],\\n 2*q[2]*q[3] + 2*q[0]*q[1],\\n q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]]])\\n return rotMat\",\n \"def rotate_point_cloud_by_angle(self, data, rotation_angle):\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n rotated_data = np.dot(data, rotation_matrix)\\n\\n return rotated_data\",\n \"def test_d_3():\\n rs = 20\\n d = 3\\n np.random.seed(rs)\\n number_rotations = 3\\n\\n theta_1 = np.random.uniform(0, 2 * math.pi)\\n rotation_1 = np.identity(d)\\n pos_1 = np.random.randint(0, d - 1)\\n pos_2 = np.random.randint(pos_1 + 1, d)\\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\\n\\n theta_2 = np.random.uniform(0, 2 * math.pi)\\n rotation_2 = np.identity(d)\\n pos_3 = np.random.randint(0, d - 1)\\n pos_4 = np.random.randint(pos_3 + 1, d)\\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\\n\\n theta_3 = np.random.uniform(0, 2 * math.pi)\\n rotation_3 = np.identity(d)\\n pos_5 = np.random.randint(0, d - 1)\\n pos_6 = np.random.randint(pos_5 + 1, d)\\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\\n\\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\\n np.random.seed(rs)\\n rotation_function = (mt_obj.calculate_rotation_matrix\\n (d, number_rotations))\\n assert(np.all(final_rotation == rotation_function))\",\n \"def augument_data(data_dir, center, left, right, steering_angle):\\n image, steering_angle = choose_random_image(data_dir, center, left, right, steering_angle)\\n # Randomly flipt the image horizontally and adjust the steering angle.\\n if np.random.rand() < 0.5:\\n image = cv2.flip(image, 1)\\n steering_angle = -steering_angle\\n \\n #translate the object with random distance in x and y direction and adjust the steering angle\\n trans_x = np.random.uniform(0, 30)\\n trans_y = np.random.uniform(0, 20)\\n steering_angle += trans_x * 0.002\\n trans_matrix = np.float32([[1, 0, trans_x], [0, 1, trans_y]])\\n height= image.shape[0]\\n width=image.shape[1]\\n image = cv2.warpAffine(image, trans_matrix, (width, height))\\n return image, steering_angle\",\n \"def test_rotating_phantom(self):\\n cheese = TomoCheese.from_demo_images()\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\\n for img in cheese.dicom_stack:\\n img.array = rotate(img.array, angle=3, mode=\\\"edge\\\")\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)\",\n \"def random_rotation_matrix():\\n\\n x = np.random.uniform(size=3)\\n theta = x[0]*2*math.pi\\n phi = x[1]*2*math.pi\\n z = x[2]*2\\n\\n r = math.sqrt(z)\\n vx = math.sin(phi)*r\\n vy = math.cos(phi)*r\\n vz = math.sqrt(2.0-z)\\n\\n st = math.sin(theta)\\n ct = math.cos(theta)\\n\\n sx = vx*ct-vy*st\\n sy = vx*st+vy*ct\\n\\n return np.array([[vx*sx-ct, vx*sy-st, vx*vz],\\n [vy*sx+st, vy*sy-ct, vy*vz],\\n [vz*sx,vz*sy,1.0-z]])\",\n \"def random_rotation_2d(batch, max_angle):\\n size = batch.shape\\n batch = np.squeeze(batch)\\n batch_rot = np.zeros(batch.shape)\\n for i in range(batch.shape[0]):\\n if bool(random.getrandbits(1)):\\n image = np.squeeze(batch[i])\\n angle = random.uniform(-max_angle, max_angle)\\n batch_rot[i] = scipy.ndimage.interpolation.rotate(image, angle, mode='nearest', reshape=False)\\n else:\\n batch_rot[i] = batch[i]\\n return batch_rot.reshape(size)\",\n \"def _rotate(self):\\n new_points = list()\\n for i in range(len(self._points)):\\n x = self._points[i][0]\\n y = self._points[i][1]\\n new_x = self._center[0] + self._center[1] - y\\n new_y = self._center[1] - self._center[0] + x\\n new_points.append((new_x, new_y))\\n return new_points\",\n \"def random_rotation(x, rg, row_axis=0, col_axis=1, channel_axis=2,\\n fill_mode='nearest', cval=0., interpolation_order=1):\\n theta = np.random.uniform(-rg, rg)\\n x = apply_affine_transform(x, theta=theta, channel_axis=channel_axis,\\n fill_mode=fill_mode, cval=cval,\\n order=interpolation_order)\\n return x\",\n \"def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n shape_pc = batch_data[k, ...]\\n rotation_matrix = rotation_matrices[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def Generate_Random( self ):\\n print( 'Generating Random coordinates' )\\n stands = self.Data.Stand.keys()\\n stands.sort()\\n for s in stands:\\n trees = self.Data.Stand[s].Tree.keys()\\n trees.sort()\\n for t in trees:\\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n beta = self.beta_sample()\\n R = Rotator.rotation_matrix(alpha,beta,0.0)\\n X = np.dot(R, X)\\n if self.random_flip and (random.rand() > 0.5):\\n X[2,:] = -X[2,:]\\n X[1,:] = -X[1,:]\\n return X\",\n \"def generate_random_DC_MT():\\n # Specify DC moment tensor to rotate:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n # And rotate DC moment tensor by random 3D angle:\\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\\n # And normallise so that moment tensor magnitude = 1:\\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\\n return random_DC_six_MT_normalised\",\n \"def rotate_random(tile):\\n return rotate(tile, random.choice([0, 1, 2, 3]))\",\n \"def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def image_rotate(Xb, batch_size):\\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\\n delta = 30. * intensity # scale by self.intensity\\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\\n return Xb\",\n \"def rotate_augmentation():\\n rand_rotate = np.random.randint(180)\\n return lambda image: rotate_with_extension(image, rand_rotate)\",\n \"def augment_cloud(Ps):\\n \\\"Augmented params:\\\"\\n pc_augm_scale=0\\n pc_augm_rot=1\\n pc_augm_mirror_prob=0.5\\n pc_augm_jitter=0\\n\\n M = transforms3d.zooms.zfdir2mat(1)\\n if pc_augm_scale > 1:\\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\\n if pc_augm_rot:\\n angle = random.uniform(0, 2*math.pi)\\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\\n result = []\\n for P in Ps:\\n P[:,:3] = np.dot(P[:,:3], M.T)\\n\\n if pc_augm_jitter:\\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\\n result.append(P)\\n return result\",\n \"def randomizePlayerPose(transform, arena_radius=8):\\n initial_r = arena_radius * random.random()\\n initial_theta = 2 * math.pi * random.random()\\n initial_x = initial_r * math.cos(initial_theta)\\n initial_y = initial_r * math.sin(initial_theta)\\n initial_rotation = 2 * math.pi * random.random()\\n transform.translation.x = initial_x\\n transform.translation.y = initial_y\\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])\",\n \"def rotate(self, z_dim=False):\\n self.x_displacement = np.format_float_scientific(\\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\\n )\\n self.y_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\\n )\\n zd = z_dim\\n if zd == True:\\n self.z_angle = random.uniform(1, 180)\\n self.z_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\\n )\\n else:\\n self.z_displacement = 0\\n self.z_angle = 0\\n return [self.x_displacement, self.y_displacement, self.z_displacement]\",\n \"def test_rot(self):\\n\\n print(\\\"rot()\\\")\\n obs = self.fixture\\n\\n # rotation(0) = identity\\n for axis in [1, 2, 3]:\\n # theta = 0.0\\n rotation = obs.rot(0.0, axis)\\n # find || eye - rot1 ||\\n diff = np.linalg.norm(np.eye(3) - rotation)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\\n # theta = 2*pi\\n rotation = obs.rot(2.0 * np.pi, axis)\\n # find || eye - rot1 ||\\n diff = np.linalg.norm(np.eye(3) - rotation)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-12)\\n\\n # perform many randomized tests\\n num_tests = 100\\n num_products = 10\\n for _test_counter in range(num_tests):\\n thetas = []\\n axes = []\\n base = np.eye(3)\\n # we will multiply a series of rotations into \\\"base\\\"\\n rot_all = base\\n for _rot_counter in range(num_products):\\n theta = np.random.uniform(2 * np.pi) # in [0,2 pi]\\n axis = np.random.randint(3) + 1 # in {1,2,3}\\n axes.append(axis)\\n thetas.append(theta)\\n rotation = obs.rot(theta, axis)\\n # multiply rot1 into the cumulative rotation\\n rot_all = np.dot(rot_all, rotation)\\n # now, back all the rotations out\\n for _rot_counter in range(num_products):\\n theta = thetas.pop()\\n axis = axes.pop()\\n # apply the inverse rotation\\n rotation = obs.rot(-theta, axis)\\n rot_all = np.dot(rot_all, rotation)\\n # find || base - rot1 * rot2 ||\\n diff = np.linalg.norm(base - rot_all)\\n self.assertAlmostEqual(diff, 0.0, delta=1e-10 * num_products)\",\n \"def generate_random_rot():\\n from pyso3.quaternion import quat2rot\\n import numpy as np\\n q = np.random.randn(4)\\n q = q / np.linalg.norm(q)\\n return quat2rot(q)\",\n \"def generate(self):\\n inside = self.crystal.is_inside(self.x,self.y,self.z)\\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\\n return self.rot.rotate(X)\",\n \"def random_rotation(x, rg, row_axis=1, col_axis=2, channel_axis=0,\\n fill_mode='nearest', cval=0.):\\n theta = np.pi / 180 * np.random.uniform(-rg, rg)\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)\\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\\n return x\",\n \"def RotateCopyPlanes(tot_ang,count,init_planes,dir_vec):\\n if isinstance(init_planes,Rhino.Geometry.Plane): init_planes=[init_planes]\\n inc=tot_ang/(count-1)\\n origin=Rhino.Geometry.Point3d(0,0,0)\\n planes=[]\\n objs=[]\\n for i in range(count):\\n for init_plane in init_planes:\\n new_plane=Rhino.Geometry.Plane(init_plane)\\n new_plane.Rotate(inc*i,dir_vec,origin)\\n planes.append(new_plane)\\n return planes\",\n \"def rotate_img(img, random):\\n degrees = 45 * (random - 0.5)\\n h, w = (int(2 * i / 3) for i in img.shape[:2])\\n img = imutils.rotate_bound(img, degrees)\\n h2, w2 = img.shape[:2]\\n x = int((w2 - w) / 2)\\n y = int((h2 - h) / 2)\\n img = img[y:y + h, x:x + w]\\n return img\",\n \"def spread_quaternions(points,num=100,quats_per_step=100):\\n quats = np.zeros((num,4))\\n rot_points = np.zeros((num,points.shape[0],3))\\n quats[0,:] = [0,0,0,1]\\n rot_points[0,:,:] = points\\n for ix in range(1,num):\\n rand_quats = random_quaternions(quats_per_step) \\n positioned = rotate_points(points,rand_quats) \\n dists = point_dists(rot_points[:ix],positioned)\\n new_rot = np.argmax(dists) \\n quats[ix,:]=rand_quats[new_rot,:]\\n rot_points[ix,:,:] = positioned[new_rot,:,:]\\n \\n return quats,rot_points\",\n \"def shuffle(self):\\n new_X = np.empty(self.X_data.shape, dtype=self.X_data.dtype)\\n new_Y = np.empty(self.Y_data.shape, dtype=self.Y_data.dtype)\\n perm = np.random.permutation(self.X_data.shape[0])\\n for old_idx, new_idx in enumerate(perm):\\n new_X[new_idx] = self.X_data[old_idx]\\n new_Y[new_idx] = self.Y_data[old_idx]\\n self.X_data = new_X\\n self.Y_data = new_Y\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def random_translation(canvas, img):\",\n \"def rotate(im: Image) -> Image:\\n return im.rotate(random.randint(0, 360))\",\n \"def rotate_array_deterministic(data):\\n return np.concatenate(\\n [data] + [np.rot90(data, k=k, axes=(1, 2)) for k in range(1, 4)], axis=0)\",\n \"def mutate_point_poly3(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def randomize(data):\\r\\n permutation = np.random.permutation(data.shape[0])\\r\\n shuffled_data = data[permutation, :]\\r\\n # shuffled_y = y[permutation]\\r\\n return shuffled_data\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def random_transform(rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask, rdrs_contains_month=False, border_masking=0, p=0.5):\\n if random.random() < p:\\n angle = random.randint(-180, 180)\\n horizontal_flip = random.choice([True, False])\\n vertical_flip = random.choice([True, False])\\n transformed_tensors = []\\n for tensor in [rdrs_batch, geophysical_batch, y_batch, y_means, train_mask.float(), val_mask.float()]:\\n images = [TF.to_pil_image(image, mode='F') for image in tensor.reshape((-1,*tensor.shape[-2:]))]\\n images = [TF.rotate(image, angle) for image in images]\\n images = [TF.hflip(image) for image in images] if horizontal_flip else images\\n images = [TF.vflip(image) for image in images] if vertical_flip else images\\n \\n transformed_tensors.append(torch.cat([TF.to_tensor(image) for image in images]).reshape(tensor.shape))\\n \\n rdrs_transformed, geophysical_transformed, y_transformed, \\\\\\n y_means_transformed, train_mask_transformed, val_mask_transformed = transformed_tensors\\n \\n # Fix \\\"month\\\" features that are all-0/all-1 images\\n if rdrs_contains_month:\\n rdrs_transformed[:,:,-12:] = rdrs_batch[:,:,-12:]\\n \\n # Do not consider subbasins that are rotated almost out of the image for training\\n border_mask = torch.zeros(train_mask.shape, dtype=torch.bool)\\n border_mask[border_masking:-border_masking,border_masking:-border_masking] = True\\n return rdrs_transformed, geophysical_transformed, y_transformed, y_means_transformed, \\\\\\n train_mask_transformed.bool() & border_mask, val_mask_transformed.bool() & border_mask\\n \\n return rdrs_batch, geophysical_batch, y_batch, y_means, train_mask, val_mask\",\n \"def rotate_3dcloud(cloud):\\n theta = np.radians(90)\\n c, s = np.cos(theta), np.sin(theta)\\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\\n return cloud.dot(Rx.T)\",\n \"def rotate_crossover(population):\\r\\n global chromosome_length\\r\\n global decryption_key\\r\\n\\r\\n new_population = []\\r\\n\\r\\n decryption_key += rotate_crossover_del\\r\\n\\r\\n # predefined rotation value, varied every round\\r\\n rotation_offset = random.randint(1, chromosome_length)\\r\\n\\r\\n decryption_key += rotation_offset_del + str(rotation_offset) + rotation_offset_del\\r\\n\\r\\n decryption_key += rotation_types_del\\r\\n\\r\\n for chromosome in population:\\r\\n\\r\\n p = random.uniform(0, 1)\\r\\n\\r\\n if p > 0.5:\\r\\n decryption_key += \\\"right|\\\"\\r\\n right_first = chromosome[0: len(chromosome) - rotation_offset]\\r\\n right_second = chromosome[len(chromosome) - rotation_offset:]\\r\\n new_population.append(right_second + right_first)\\r\\n else:\\r\\n decryption_key += \\\"left|\\\"\\r\\n left_first = chromosome[0: rotation_offset]\\r\\n left_second = chromosome[rotation_offset:]\\r\\n new_population.append(left_second + left_first)\\r\\n\\r\\n decryption_key += rotation_types_del\\r\\n\\r\\n decryption_key += rotate_crossover_del\\r\\n\\r\\n return new_population\",\n \"def reset(self):\\n self.x = random.uniform(-0.05, 0.05)\\n self.x_dot = random.uniform(-0.05, 0.05)\\n self.theta = random.uniform(-0.05, 0.05)\\n self.theta_dot = random.uniform(-0.05, 0.05)\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:,idx,:]\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def __randomize_data(self):\\n times = map(lambda (t, _): t, self.data)\\n coords = map(lambda (_, c): c, self.data)\\n return zip(times, map(DataGen.__randomize_coord, coords))\",\n \"def test_rotate_up(self):\\n # Testing 'up' rotation clockwise\\n side = 'U'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def rotation3(size=None): # noqa\\n if size is None:\\n size = ()\\n else:\\n try:\\n size = tuple(size)\\n except TypeError:\\n size = (size,)\\n theta, phi, z = 2. * random((3, 1) + size)\\n theta *= pi # Initial rotation angle about z-axis.\\n phi *= pi # Angle in xy plane for tilt of z-axis.\\n # Magnitude of tilt is random variable z.\\n r = sqrt(z)\\n v = concatenate((r*sin(phi), r*cos(phi), sqrt(2.-z)))\\n st, ct = sin(theta), cos(theta)\\n s = concatenate((v[0]*ct - v[1]*st, v[0]*st + v[1]*ct))\\n m = v[:, newaxis].repeat(3, axis=1)\\n m[:, :2] *= s\\n m[0, :2] -= concatenate((ct, st))\\n m[1, :2] += concatenate((st, -ct))\\n m[:2, 2] *= v[2]\\n m[2, 2] = 1. - z # Equals v[2]*v[2] - 1.\\n if m.ndim > 2:\\n m = transpose(m, roll(range(m.ndim), -2)).copy()\\n return m\",\n \"def random_transform_extension(self, x, y, seed=None):\\n # x is a single image, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n # use composition of homographies\\n # to generate final transform that needs to be applied\\n if self.rotation_range:\\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(-self.shear_range, self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\\n\\n transform_matrix = None\\n if theta != 0:\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n transform_matrix = rotation_matrix\\n\\n if tx != 0 or ty != 0:\\n shift_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\\n\\n if shear != 0:\\n shear_matrix = np.array([[1, -np.sin(shear), 0],\\n [0, np.cos(shear), 0],\\n [0, 0, 1]])\\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\\n\\n if zx != 1 or zy != 1:\\n zoom_matrix = np.array([[zx, 0, 0],\\n [0, zy, 0],\\n [0, 0, 1]])\\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\\n\\n if transform_matrix is not None:\\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n if self.channel_shift_range != 0:\\n x = image.random_channel_shift(x,\\n self.channel_shift_range,\\n img_channel_axis)\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_col_axis)\\n y = kimage.flip_axis(y, img_col_axis)\\n\\n if self.vertical_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_row_axis)\\n y = kimage.flip_axis(y, img_row_axis)\\n return x, y\",\n \"def random_transpose(pianoroll):\\n semitone = np.random.randint(-5, 6)\\n if semitone > 0:\\n pianoroll[:, semitone:, 1:] = pianoroll[:, :-semitone, 1:]\\n pianoroll[:, :semitone, 1:] = 0\\n elif semitone < 0:\\n pianoroll[:, :semitone, 1:] = pianoroll[:, -semitone:, 1:]\\n pianoroll[:, semitone:, 1:] = 0\\n return pianoroll\",\n \"def generate_random_MT_Lune_samp():\\n # 1. Get randomly varied Lune parameters (gamma and delta):\\n # Define U rotation matrix (See Tape and Tape 2012/2013):\\n U_rot_matrix = (1./np.sqrt(6))*np.vstack(([np.sqrt(3.),0.,-np.sqrt(3.)],[-1.,2.,-1.], [np.sqrt(2.),np.sqrt(2.),np.sqrt(2.)]))\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random delta and gamma Lune angles:\\n delta = np.random.uniform(-np.pi/2., np.pi/2.) # theta, but shifted to range between -pi/2 and pi/2 (See Tape and Tape 2012/2013)\\n beta = (np.pi/2.) - delta # Beta is simply phase shift of delta (See Tape and Tape 2012/2013)\\n gamma = np.random.uniform(-np.pi/6., np.pi/6.) # phi, but shifted to range between -pi/6 and pi/6 (See Tape and Tape 2012/2013)\\n # Get eigenvalues from delta,gamma,beta:\\n lune_space_uvw_vec = np.vstack(([np.cos(gamma)*np.sin(beta)], [np.sin(gamma)*np.sin(beta)], [np.cos(beta)]))\\n lambda_vec = np.dot(np.transpose(U_rot_matrix), lune_space_uvw_vec) # (See Tape and Tape 2012, eq. 20)\\n Lune_space_MT = np.vstack(([lambda_vec[0],0.,0.],[0.,lambda_vec[1],0.], [0.,0.,lambda_vec[2]])) # MT with principle axes in u,v,w Lune space\\n # 2. Get theta and phi angles to rotate Lune_space_MT by to randomly rotate into x,y,z space:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z)\\n phi = np.arctan2(y,x)\\n # 3. Rotate Lune_space_MT from u,v,w coords to x,y,z coords:\\n random_MT = rot_mt_by_theta_phi(Lune_space_MT, theta, phi)\\n random_six_MT = get_six_MT_from_full_MT_array(random_MT)\\n # And normallise so that moment tensor magnitude = 1:\\n random_six_MT_normalised = random_six_MT/((np.sum(random_six_MT**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n random_six_MT_normalised = np.reshape(random_six_MT_normalised, (6, 1))\\n return random_six_MT_normalised\",\n \"def test_transform_3d(transform, alpha = 1):\\r\\n points = 20*[None]\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n points[i] = vec3(x, y, z)\\r\\n tr_x = random.randrange(-40, 41)\\r\\n tr_y = random.randrange(-40, 41)\\r\\n tr_z = random.randrange(-40, 41)\\r\\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\\r\\n print(\\\"Translation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Translation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n th_x = 2*math.pi*random.random()\\r\\n th_y = 2*math.pi*random.random()\\r\\n th_z = 2*math.pi*random.random()\\r\\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\\r\\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\\r\\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\\r\\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\\r\\n print(\\\"Rotation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Rotation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\\r\\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\\r\\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k = math.exp(2*random.random() - 1)\\r\\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\\r\\n print(\\\"Uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k*x, k*y, k*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k_x = math.exp(2*random.random() - 1)\\r\\n k_y = 3*random.random() + 1\\r\\n k_z = 3*random.random() + 1\\r\\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\\r\\n else: k_y = k_x + k_y\\r\\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\\r\\n else: k_z = (k_x + k_y)/2 + k_z\\r\\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\\r\\n print(\\\"Non-uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\",\n \"def mutate_point_circ(mutated_genome):\\n seed = random.randint(0,3)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_circ(mutated_genome,index)\\n elif seed == 1:\\n shift_point_circ(mutated_genome,index)\\n elif seed == 2:\\n move_radius_circ(mutated_genome,index)\\n else: #seed == 3:\\n shift_radius_circ(mutated_genome,index)\",\n \"def rotate_points(points, rot):\\n t0 = time.time()\\n points_rot = points.transpose()\\n points_rot = rot @ points_rot\\n points_rot = points_rot.transpose()\\n # print(f\\\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\\\")\\n return points_rot\",\n \"def generate_random_DC_single_force_coupled_tensor():\\n # 1. --- Specify DC moment tensor to rotate ---:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # 2. --- Specify single force 3-vector in same direction as slip of DC solution ---:\\n NED_single_force_vector_to_rotate = np.array([1.,0.,0.], dtype=float)\\n # 3. --- Rotate DC moment tensor and single force by same random rotation on sphere:\\n # 3.a. Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n # 3.b. Rotate DC moment tensor by random 3D angle:\\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5) # And normallise so that moment tensor magnitude = 1\\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1)) # And set to correct dimensions (so matrix multiplication in forward model works correctly)\\n # 3.c. Rotate Single force 3-vector by the same random 3D angle:\\n random_coupled_NED_single_force = rot_single_force_by_theta_phi(NED_single_force_vector_to_rotate, theta, phi)\\n random_coupled_single_force = np.array([random_coupled_NED_single_force[1], random_coupled_NED_single_force[0], random_coupled_NED_single_force[2]]) # Convert single force from NED coords to END coords (as that is what greens functions are in)\\n random_coupled_single_force = np.reshape(random_coupled_single_force, (3, 1))\\n # 4. --- Get random fraction amplitude DC and single force components (sum of amplitudes is to 1) ---:\\n random_amp_frac = random.random() # random number between 0. and 1.\\n random_DC_six_MT_normalised = random_DC_six_MT_normalised*random_amp_frac\\n random_coupled_single_force = random_coupled_single_force*(1.-random_amp_frac)\\n # 5. --- Finally combine to tensor of length 9 ---:\\n random_DC_single_force_coupled_tensor = np.vstack((random_DC_six_MT_normalised, random_coupled_single_force))\\n return random_DC_single_force_coupled_tensor, random_amp_frac\",\n \"def rotateZ(self, *args, **kwargs):\\n ...\",\n \"def sample_direction():\\r\\n gamma = random.random()\\r\\n mu = 2*gamma-1\\r\\n gamma = random.random()\\r\\n phi = 2*np.pi*gamma\\r\\n direction = [np.sqrt(1-mu**2)*np.cos(phi), np.sqrt(1-mu**2)*np.sin(phi), mu]\\r\\n return direction\",\n \"def _random_permutation(self):\\n self.train_permutation = numpy.random.permutation(range(len(self.train_list)))\",\n \"def random_params_gen(self) -> TransformParams:\\n while True:\\n do_hor_flip = self.horizontal_flip and (np.random.random() < 0.5)\\n do_vert_flip = self.vertical_flip and (np.random.random() < 0.5)\\n\\n yield TransformParams(do_hor_flip=do_hor_flip,\\n do_vert_flip=do_vert_flip)\",\n \"def repick(g1_x, g1_y, g1_z):\\n i = random.randint(0, len(g1_x) - 1)\\n x = g1_x[i]\\n y = g1_y[i]\\n z = g1_z[i]\\n return x, y, z\",\n \"def mutate_point_trig(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_trig(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_trig(mutated_genome,index)\",\n \"def randomcorners():\\n r = lambda x: random.randint(int(x*0.4), int(x*0.6))\\n cx = r(gs.DEFAULTS['width'])\\n cy = r(gs.DEFAULTS['height'])\\n\\n w = int(gs.DEFAULTS['width'] * random.random() * 0.2)\\n h = int(gs.DEFAULTS['height'] * random.random() * 0.2)\\n\\n rcrns = [(cx-w, cy-h), (cx+w, cy-h), (cx+w, cy+h), (cx-w, cy+h)]\\n random.shuffle(rcrns)\\n\\n return rcrns\",\n \"def rotate_points(points,quaternions):\\n \\n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \\n res[:,:,1:] = points \\n conjugates = conjugate(quaternions) \\n \\n for ix in range(len(points)):\\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\\n return res[:,:,1:]\",\n \"def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\\n # get a random angle\\n angle = np.random.randint(0, self.rotate)\\n # get a random sign for the angle\\n sign = np.random.randint(0, 2)\\n x = rotate(x, -sign * angle, reshape=False)\\n m = rotate(m, -sign * angle, axes=(0, 1),\\n mode='nearest',\\n reshape=False)\\n return x, m\",\n \"def test_random_transform():\\n # given\\n train = pd.read_csv('source/train.csv')\\n train['labels'] = train['labels'].map(ast.literal_eval)\\n image_path = os.path.join('source', train.iloc[0].path)\\n all_labels = train.iloc[0]['labels']\\n for label in all_labels:\\n if label['class'] == 'whiteboard':\\n break\\n xn = [int(float(x)) for x in label['xn'].split(';')][:4]\\n yn = [int(float(y)) for y in label['yn'].split(';')][:4]\\n labels = np.zeros((4, 2))\\n for i in range(4):\\n labels[i, 0] = xn[i]\\n labels[i, 1] = yn[i]\\n img = cv2.imread(image_path)\\n kw = dict(rotation_range=15,\\n height_shift_range=0.2,\\n width_shift_range=0.2,\\n shear_range=0.3,\\n channel_shift_range=0.2,\\n horizontal_flip=True,\\n vertical_flip=True,\\n dim_ordering='tf',\\n seed=1313)\\n # when\\n rimg, rlabels = image_generator.random_transform(img, labels, **kw)\\n\\n # then just assert transformation isn't changed much\\n assert MultiPoint([[224.91875347, 58.05657097],\\n [673.57648317, 189.27244333],\\n [544.23308452, 381.12743459],\\n [70.73339963, 312.7359806]]\\n ).equals_exact(rlabels, 5)\",\n \"def generate_random_DC_crack_coupled_tensor():\\n # 1. Generate random DC MT and crack MT:\\n # generate DC MT:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\\n # Get between small range:\\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\\n random_num = random.random()\\n if random_num <= 0.5:\\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\\n elif random_num > 0.5:\\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n # And redistribute evenly everywhere on boundary:\\n random_num = random.random()\\n if random_num>0.25 and random_num<=0.5:\\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\\n if random_num>0.5 and random_num<=0.75:\\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\\n if random_num>0.75 and random_num<=1.0:\\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\\n # --- ---\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # theta_lune_sphere = random.random()*np.pi/2.\\n # elif random_num > 0.5:\\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # phi_lune_sphere = np.pi/6.\\n # elif random_num > 0.5:\\n # phi_lune_sphere = -1.*np.pi/6.\\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\\n # 2. Combine DC and crack tensors:\\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\\n # 3. Randomly rotate DC-crack MT to random orientation:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\\n # 4. Normalise and get 6 MT:\\n # Get 6 MT:\\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\\n # And normallise so that moment tensor magnitude = 1:\\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\\n return DC_crack_six_MT_rotated_normalised, random_amp_frac\",\n \"def rotateZ(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n x = self.x * cosa - self.y * sina\\r\\n y = self.x * sina + self.y * cosa\\r\\n return Point3D(x, y, self.z)\",\n \"def orient_point_cloud_to_ground_plane(xyz_arr, roi_point_cloud, thetas, phis, num_points, num_planes, memory):\\n\\tcenter, plane, phi, theta = get_orientation(roi_point_cloud, num_points, num_planes)\\n\\tthetas = np.append(thetas, theta)\\n\\tphis = np.append(phis, phi)\\n\\t# print(center, plane, np.median(theta), np.median(phis))\\n\\tCameraPosition['elevation'] = np.median(thetas)\\n\\tCameraPosition['azimuth'] = np.median(phis)\\n\\tif thetas.size > memory:\\n\\t\\tthetas = thetas[1:]\\n\\tif phis.size > memory:\\n\\t\\tphis = phis[1:]\\n\\tf = open(localization_dir + '%d.json' % len(os.listdir(localization_dir)),'w')\\n\\tf.write(json.dumps(CameraPosition))\\n\\tf.close()\\n\\tcenter = apply_camera_orientation(center, CameraPosition)\\n\\tplane = apply_camera_orientation(plane, CameraPosition)\\n\\txyz_arr = apply_camera_matrix_orientation(xyz_arr, CameraPosition)\\n\\treturn xyz_arr, roi_point_cloud, center\",\n \"def random_perm3(data_x, data_y, data_z):\\n data_size = data_y.shape[0]\\n rand_perm = np.arange(data_size)\\n np.random.shuffle(rand_perm)\\n random_data_x = []\\n random_data_z = []\\n for indices in rand_perm: # 'List' object, more complicated !!!\\n random_data_x.append(data_x[indices])\\n random_data_z.append(data_z[indices])\\n # random_data_x = data_x[rand_perm]\\n random_data_y = data_y[rand_perm]\\n # random_data_z = data_z[rand_perm]\\n return random_data_x, random_data_y, random_data_z\",\n \"def random_point():\\n theta = numpy.arccos(2. * numpy.random.random() - 1)\\n phi = 2 * numpy.pi * numpy.random.random()\\n return theta, phi\",\n \"def randomize(self, amplitude):\\n from random import gauss\\n # update alignment from projections\\n self.getMarkersFromTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\\n\\n # add random amplitude\\n # markers\\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\\n for (imark, mark) in enumerate(self._Markers):\\n if (imark + 1) != irefmark:\\n r = mark.get_r()\\n for ii in range(0, 3):\\n r[ii] = gauss(0, amplitude) + r[ii]\\n self._Markers[imark].set_r(r)\\n\\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\\n # translations, rotations, magnifications\\n for itilt in range(0, self._ntilt):\\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\\n if (self._projIndices[itilt] != ireftilt):\\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\\n\\n # update alignment from projections\\n self.setMarkersInTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n R = Rotator.rotation_matrix(alpha,0.0,0.0)\\n return np.dot(R,X)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n\\n beta = np.arccos(1.0-2*random.rand())\\n psi = random.rand() * 2*pi\\n\\n R = Rotator.rotation_matrix(alpha,beta,psi)\\n return np.dot(R,X)\",\n \"def generator(samples, batch_size=32, is_training=True):\\n num_samples = len(samples)\\n\\n #vertical, horizontal range for random translation\\n x_translate_range = 100\\n y_translate_range = 10\\n\\n while 1: # Loop forever so the generator never terminates\\n #shuffle the samples once the whole data is processed into batches\\n shuffle(samples)\\n #split data into batches\\n for offset in range(0, num_samples, batch_size):\\n batch_samples = samples[offset:offset+batch_size]\\n images = []\\n angles = []\\n for batch_sample in batch_samples:\\n # corrections for centered view image, left camera view image and right camera view image\\n corrections = [0,0.2,-0.2]\\n # iterate over center, right and left camera view images\\n for i in range(3):\\n current_path = get_image_path(batch_sample[i])\\n\\n # read image\\n image = cv2.imread(current_path)\\n # append image for training/validation\\n images.append(preprocess(image))\\n\\n # calculate angle measurement with applied angle corrections\\n measurement = float(batch_sample[3]) + corrections[i]\\n angles.append(measurement)\\n\\n # insert flipped image for opposite direction generalization\\n images.append(preprocess(cv2.flip(image, 1)))\\n angles.append(measurement*-1.0)\\n\\n # create random augmented image only for training\\n if is_training:\\n image, measurement = flip_image(image, measurement, flip_probability=0.5)\\n image = add_salt_pepper_noise(image)\\n image, measurement = random_translate(image, measurement, x_translate_range, y_translate_range)\\n image = random_shadow(image)\\n image = random_brightness(image)\\n images.append(preprocess(image))\\n angles.append(measurement)\\n\\n # create X, y dataset\\n X_train = np.array(images)\\n y_train = np.array(angles)\\n\\n yield sklearn.utils.shuffle(X_train, y_train)\",\n \"def __call__(self, results):\\n if np.random.rand() > self.prob:\\n return results\\n h, w = results['image'].shape[:2]\\n center = self.center\\n if center is None:\\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\\n angle = random_negative(self.angle, self.random_negative_prob)\\n self._rotate_img(results, angle, center, self.scale)\\n return results\",\n \"def shift(self):\\n \\\"\\\"\\\"\\n shift cluster randomly within bounds of im\\n \\\"\\\"\\\"\\n r = self.std\\n mid = self.mid_pixel #center pixel index of 384x384 image\\n delta = self.im_size - self.mid_pixel - r - 10\\n \\n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n\\n self.x += x\\n self.y += y\\n im_shift = np.roll(self.im,shift=y,axis=0)\\n self.im = np.roll(im_shift,shift=x,axis=1)\\n \\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7385551","0.69660366","0.69539493","0.69265366","0.69265366","0.69265366","0.6815256","0.67491716","0.6693226","0.66440564","0.65964067","0.65964067","0.65964067","0.65239024","0.6469736","0.64177275","0.63704824","0.6198356","0.61689585","0.6100769","0.59592277","0.5929809","0.5922679","0.5862622","0.5850506","0.57965016","0.5740949","0.57060665","0.569531","0.5693229","0.56511706","0.5638733","0.5626663","0.5621198","0.5619053","0.56161946","0.56090295","0.559958","0.55705374","0.5547688","0.55155325","0.5508486","0.5502968","0.54868907","0.5480431","0.54791266","0.5459183","0.545753","0.54541326","0.545022","0.5449854","0.5445457","0.54278827","0.5412151","0.5400084","0.5396345","0.5395041","0.5391269","0.53910834","0.53730726","0.5369676","0.5354136","0.5351305","0.53493816","0.53398216","0.5316802","0.53163844","0.531288","0.53026855","0.5301321","0.5274109","0.5254204","0.52476406","0.5243415","0.5238725","0.52375114","0.5234045","0.5232799","0.5224902","0.5194452","0.5191426","0.5189438","0.5185891","0.5183889","0.5181442","0.5180007","0.51715153","0.5168858","0.51636237","0.5163186","0.51556265","0.51507455","0.5149818","0.51482475","0.5146931","0.5145105","0.51421934","0.51411813","0.5141166"],"string":"[\n \"0.7385551\",\n \"0.69660366\",\n \"0.69539493\",\n \"0.69265366\",\n \"0.69265366\",\n \"0.69265366\",\n \"0.6815256\",\n \"0.67491716\",\n \"0.6693226\",\n \"0.66440564\",\n \"0.65964067\",\n \"0.65964067\",\n \"0.65964067\",\n \"0.65239024\",\n \"0.6469736\",\n \"0.64177275\",\n \"0.63704824\",\n \"0.6198356\",\n \"0.61689585\",\n \"0.6100769\",\n \"0.59592277\",\n \"0.5929809\",\n \"0.5922679\",\n \"0.5862622\",\n \"0.5850506\",\n \"0.57965016\",\n \"0.5740949\",\n \"0.57060665\",\n \"0.569531\",\n \"0.5693229\",\n \"0.56511706\",\n \"0.5638733\",\n \"0.5626663\",\n \"0.5621198\",\n \"0.5619053\",\n \"0.56161946\",\n \"0.56090295\",\n \"0.559958\",\n \"0.55705374\",\n \"0.5547688\",\n \"0.55155325\",\n \"0.5508486\",\n \"0.5502968\",\n \"0.54868907\",\n \"0.5480431\",\n \"0.54791266\",\n \"0.5459183\",\n \"0.545753\",\n \"0.54541326\",\n \"0.545022\",\n \"0.5449854\",\n \"0.5445457\",\n \"0.54278827\",\n \"0.5412151\",\n \"0.5400084\",\n \"0.5396345\",\n \"0.5395041\",\n \"0.5391269\",\n \"0.53910834\",\n \"0.53730726\",\n \"0.5369676\",\n \"0.5354136\",\n \"0.5351305\",\n \"0.53493816\",\n \"0.53398216\",\n \"0.5316802\",\n \"0.53163844\",\n \"0.531288\",\n \"0.53026855\",\n \"0.5301321\",\n \"0.5274109\",\n \"0.5254204\",\n \"0.52476406\",\n \"0.5243415\",\n \"0.5238725\",\n \"0.52375114\",\n \"0.5234045\",\n \"0.5232799\",\n \"0.5224902\",\n \"0.5194452\",\n \"0.5191426\",\n \"0.5189438\",\n \"0.5185891\",\n \"0.5183889\",\n \"0.5181442\",\n \"0.5180007\",\n \"0.51715153\",\n \"0.5168858\",\n \"0.51636237\",\n \"0.5163186\",\n \"0.51556265\",\n \"0.51507455\",\n \"0.5149818\",\n \"0.51482475\",\n \"0.5146931\",\n \"0.5145105\",\n \"0.51421934\",\n \"0.51411813\",\n \"0.5141166\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6815286"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":9465,"cells":{"query":{"kind":"string","value":"Randomly perturb the point clouds by small rotations"},"document":{"kind":"string","value":"def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\n return rotated_data"},"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_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def random_rotation(self, img, p = 0.5):\n if self.decision(p):\n theta = random.randrange(-15, 15)\n phi = random.randrange(-15, 15)\n gamma = random.randrange(-15, 15)\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\n # check if cut is ahve to much dark pixels, more then 20 %\n non_zeros = np.count_nonzero(roi)\n non_zeros_procent = non_zeros / roi.size\n if non_zeros_procent < 0.8:\n pass\n else:\n img = roi\n return img","def rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\n ## https://en.wikipedia.org/wiki/Rotation_matrix\n if(use_rotation_tensor != True):\n angle_range = DEGREES\n x_angle = radians(random.random() * angle_range)\n y_angle = radians(random.random() * angle_range)\n z_angle = radians(random.random() * angle_range)\n\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\n rotation_matrix = torch.mm(rot_y, rot_z)\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \n\n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n \n \n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\n self.rotation_matrix = rotation_matrix\n \n if(save_rotation_tensor):\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\n else: \n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\n return pointcloud_model_rotated[:,:,0:3]","def augment_cloud(Ps):\n \"Augmented params:\"\n pc_augm_scale=0\n pc_augm_rot=1\n pc_augm_mirror_prob=0.5\n pc_augm_jitter=0\n\n M = transforms3d.zooms.zfdir2mat(1)\n if pc_augm_scale > 1:\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\n if pc_augm_rot:\n angle = random.uniform(0, 2*math.pi)\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\n result = []\n for P in Ps:\n P[:,:3] = np.dot(P[:,:3], M.T)\n\n if pc_augm_jitter:\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\n result.append(P)\n return result","def randomPointOnSphere(r):\n x = np.random.normal()\n y = np.random.normal()\n z = np.random.normal()\n point = np.array([x, y, z])\n point *= r/(x**2 + y**2 + z**2)**.5\n return point","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def randomize_trajectory(self):\n self.angle = randint(-360, 360)\n self.speed = randint(1, 5)/2.5","def rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\n return rotated_data","def resample_particles(self):\n # make sure the distribution is normalized\n self.normalize_particles()\n\n newParticles = []\n for i in range(len(self.particle_cloud)):\n # resample the same # of particles\n choice = random_sample()\n # all the particle weights sum to 1\n csum = 0 # cumulative sum\n for particle in self.particle_cloud:\n csum += particle.w\n if csum >= choice:\n # if the random choice fell within the particle's weight\n newParticles.append(deepcopy(particle))\n break\n self.particle_cloud = newParticles","def _sample_k_new(self, cur_y, cur_z):\n N = float(len(self.obs))\n #old_loglik = self._loglik(cur_y, cur_z)\n\n k_new_count = np.random.poisson(self.alpha / N)\n if k_new_count == 0: return False\n \n # modify the feature ownership matrix\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\n # propose feature images by sampling from the prior distribution\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\n \n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def reroll(self):\n self._base_x = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._x_min,\n self.base_point_distribution._x_max\n )\n self._base_y = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._y_min,\n self.base_point_distribution._y_max\n )","def mutate(self, size):\n rand = random.random()\n if rand <= 0.5:\n print u\"changing colour\"\n idx = random.randrange(0, 4)\n value = random.randrange(0, 256)\n colour = list(self.colour)\n colour[idx] = value\n self.colour = tuple(colour)\n else:\n print u\"changing point\"\n idx = random.randrange(0, len(self.points))\n point = generate_point(size[0], size[1])\n self.points[idx] = point","def mutate_point_poly3(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def random_rotate(self):\r\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\r\n flip = rand.randrange(0, 2, 1) # 0, 1\r\n new_seed = copy.deepcopy(self)\r\n # rotate by 90 degrees * rotation (0, 90, 180 270)\r\n new_seed.cells = np.rot90(new_seed.cells, rotation) \r\n if (flip == 1):\r\n # flip upside down\r\n new_seed.cells = np.flipud(new_seed.cells)\r\n new_seed.xspan = new_seed.cells.shape[0]\r\n new_seed.yspan = new_seed.cells.shape[1]\r\n return new_seed","def spread_quaternions(points,num=100,quats_per_step=100):\n quats = np.zeros((num,4))\n rot_points = np.zeros((num,points.shape[0],3))\n quats[0,:] = [0,0,0,1]\n rot_points[0,:,:] = points\n for ix in range(1,num):\n rand_quats = random_quaternions(quats_per_step) \n positioned = rotate_points(points,rand_quats) \n dists = point_dists(rot_points[:ix],positioned)\n new_rot = np.argmax(dists) \n quats[ix,:]=rand_quats[new_rot,:]\n rot_points[ix,:,:] = positioned[new_rot,:,:]\n \n return quats,rot_points","def _sample_lam(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_lam = self.lam\n \n # modify the feature ownership matrix\n self.lam = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.lam = old_lam","def initialise_particle_cloud(self, initialpose):\n # ----- Initialize the particle cloud as an empty array\n self.particlecloud = PoseArray()\n\n \"\"\"Create the noise to multiply by the random Gaussian number that will\n get added to each of the Poses, that are set to a random position\n and orientation around the initial pose\"\"\"\n sensorSigma=3 #variance\n sensorMu=0 #mean\n noise=sensorSigma * numpy.random.randn() + sensorMu\n\n \"\"\"Create a range for the ammount of random Gaussian values to generate \"\"\"\n randomGauss = 10*self.NUMBER_PREDICTED_READINGS\n\n gaussianRandomNumX = []\n gaussianRandomNumY = []\n randomYawArray = []\n\n for i in range (0,randomGauss):\n gaussianRandomNumX.append(random.gauss(0,1))\n gaussianRandomNumY.append(random.gauss(0,1))\n x=random.randint(1,180)\n randomYaw=(math.pi/x)\n randomYawArray.append(randomYaw)\n\n iterator = 0\n\n \"\"\"\n\t Set the particles to a random position and orientation around the initial pose\n \"\"\"\n particleNumber = 10**2 # 10**3 # 10**4 # 10**5 experiment with different ammounts of particles\n\n while iterator < particleNumber:\n particle = Pose()\n particle.position.x = initialpose.pose.pose.position.x + (gaussianRandomNumX[iterator] * noise)\n particle.position.y = initialpose.pose.pose.position.y + (gaussianRandomNumY[iterator] * noise)\n particle.position.z = initialpose.pose.pose.position.z\n particle.orientation = rotateQuaternion(initialpose.pose.pose.orientation, randomYawArray[iterator])\n\n self.particlecloud.poses.append(particle)\n iterator += 1\n\n return self.particlecloud","def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\n for sampling_result, img_meta in zip(sampling_results, img_metas):\n bboxes = sampling_result.pos_bboxes\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\n -amplitude, amplitude)\n # before jittering\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\n # after jittering\n new_cxcy = cxcy + wh * random_offsets[:, :2]\n new_wh = wh * (1 + random_offsets[:, 2:])\n # xywh to xyxy\n new_x1y1 = (new_cxcy - new_wh / 2)\n new_x2y2 = (new_cxcy + new_wh / 2)\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\n # clip bboxes\n max_shape = img_meta['img_shape']\n if max_shape is not None:\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\n\n sampling_result.pos_bboxes = new_bboxes\n return sampling_results","def uniform_random(self) -> None:\n\n size = self.circ_size\n random.seed(self.seed)\n\n gates = [self.h, self.x, self.y, self.z, self.s, self.t, self.cx]\n candidates = set(range(size))\n\n for i in range(size):\n for j in range(size):\n to_apply = random.choice(gates)\n\n num_qubits = 2 if to_apply == self.cx else 1\n targets = random.sample(candidates, num_qubits)\n to_apply(*targets)\n\n if self.meas: self.measure(self.qr, self.cr)","def mutate_point_circ(mutated_genome):\n seed = random.randint(0,3)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_circ(mutated_genome,index)\n elif seed == 1:\n shift_point_circ(mutated_genome,index)\n elif seed == 2:\n move_radius_circ(mutated_genome,index)\n else: #seed == 3:\n shift_radius_circ(mutated_genome,index)","def getRandomCentroids(data_points, k):\n return random.sample(data_points, k)","def generate_random_surface_points() -> List[SurfacePoint]:\n surface_points: List[SurfacePoint] = []\n for _ in range(42):\n surface_point = SurfacePoint(\n idx=uuid.uuid4().hex,\n x=_gen_random_number(),\n y=_gen_random_number(),\n z=_gen_random_number(),\n x_uc_dist=DistUcEnum.uniform,\n x_uc=_gen_random_number(),\n y_uc_dist=DistUcEnum.uniform,\n y_uc=_gen_random_number(),\n z_uc_dist=DistUcEnum.uniform,\n z_uc=_gen_random_number(),\n smooth=0.01,\n formation=\"Formation_0\",\n )\n surface_points.append(surface_point)\n return surface_points","def generate_base_points(num_points, domain_size, density_map=None,\n reflect=True):\n\n def _try_points(num_points, prob):\n prob = np.atleast_3d(prob)\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\n base_pts = []\n N = 0\n while N < num_points:\n pt = np.random.rand(3) # Generate a point\n # Test whether to keep it or not\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\n if np.random.rand(1) <= prob[indx][indy][indz]:\n base_pts.append(pt)\n N += 1\n base_pts = np.array(base_pts)\n return base_pts\n\n if len(domain_size) == 1: # Spherical\n domain_size = np.array(domain_size)\n r = domain_size[0]\n if density_map is None:\n # Make an image of a sphere filled with ones and use _try_points\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, 20] = 0\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to spherical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\n # Reflect base points across perimeter\n if reflect:\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_spherical(r, theta, phi)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 2: # Cylindrical or Disk\n domain_size = np.array(domain_size)\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, :] = 0\n if domain_size[1] == 0: # Disk\n density_map = density_map[:, :, 0]\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to cylindrical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n z = Z*domain_size[1]\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n inds = ~((z > domain_size[1]) + (z < 0))\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n if reflect:\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_cylindrical(r, theta, z)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 3: # Cube or square\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n if domain_size[2] == 0:\n density_map = density_map[:, :, 0]\n base_pts = _try_points(num_points, density_map)\n base_pts = base_pts*domain_size\n if reflect:\n base_pts = reflect_base_points(base_pts, domain_size)\n\n return base_pts","def realize(self):\n if numpy.random.rand() > self._P:\n self._w *= 0.0","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def point_sample(img_meta,\n img_features,\n points,\n proj_mat,\n coord_type,\n img_scale_factor,\n img_crop_offset,\n img_flip,\n img_pad_shape,\n img_shape,\n aligned=True,\n padding_mode='zeros',\n align_corners=True):\n\n # apply transformation based on info in img_meta\n points = apply_3d_transformation(\n points, coord_type, img_meta, reverse=True)\n\n # project points to camera coordinate\n pts_2d = points_cam2img(points, proj_mat)\n\n # img transformation: scale -> crop -> flip\n # the image is resized by img_scale_factor\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\n img_coors -= img_crop_offset\n\n # grid sample, the valid grid range should be in [-1,1]\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\n\n if img_flip:\n # by default we take it as horizontal flip\n # use img_shape before padding for flip\n orig_h, orig_w = img_shape\n coor_x = orig_w - coor_x\n\n h, w = img_pad_shape\n coor_y = coor_y / h * 2 - 1\n coor_x = coor_x / w * 2 - 1\n grid = torch.cat([coor_x, coor_y],\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\n\n # align_corner=True provides higher performance\n mode = 'bilinear' if aligned else 'nearest'\n point_features = F.grid_sample(\n img_features,\n grid,\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners) # 1xCx1xN feats\n\n return point_features.squeeze().t()","def generate_random_point(det):\n xmin, ymin, zmin = det.ActiveVolume().Min()\n xmax, ymax, zmax = det.ActiveVolume().Max()\n return geoalgo.Vector(np.random.random() * (xmax - xmin) + xmin,\n np.random.random() * (ymax - ymin) + ymin,\n np.random.random() * (zmax - zmin) + zmin)","def _generate_pores(self):\n logger.info(\"Place randomly located pores in the domain\")\n #Original Random Point Generator\n #coords = sp.rand(self._Np,3)*[self._Lx,self._Ly,self._Lz]\n #Seeding Code\n coords = np.zeros([self._Np,3])\n #reject points close to boundaries - if False there will be slightly more\n rejection = [False,False,True]\n for j in range(3):\n i = 0\n while i < self._Np:\n coord = np.random.uniform(0,1,1)\n if self._reject(coord) == rejection[j]:\n coords[i][j]=coord\n i += 1\n coords*=np.array([self._Lx,self._Ly,self._Lz])\n #Seeding Code\n #Uniform Random Generator\n #coords = np.array([np.random.uniform(0,self._Lx,self._Np),np.random.uniform(0,self._Ly,self._Np),np.random.uniform(0,self._Lz,self._Np)]).T\n\n self['pore.coords'] = coords\n logger.debug(\"End of method\")","def mutate_point_trig(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_trig(mutated_genome,index)\n else: #seed == 1:\n shift_point_trig(mutated_genome,index)","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def pepper(self, prob=0.08):\n h, w, c = self.img.shape\n for i in range(h):\n for j in range(w):\n if random() < prob:\n self.img[i, j] = 0\n\n self.edits.append(f\"pepper:{prob}\")\n return self","def prep_pointcloud(input_dict,\n root_path,\n voxel_generator,\n target_assigner,\n db_sampler=None,\n max_voxels=20000,\n max_sweeps=10,\n remove_outside_points=False,\n training=True,\n create_targets=True,\n shuffle_points=False,\n remove_unknown=False,\n gt_rotation_noise=(-np.pi / 3, np.pi / 3),\n gt_loc_noise_std=(1.0, 1.0, 1.0),\n global_rotation_noise=(-np.pi / 4, np.pi / 4),\n global_scaling_noise=(0.95, 1.05),\n global_random_rot_range=(0.78, 2.35),\n global_translate_noise_std=(0, 0, 0),\n num_point_features=4,\n anchor_area_threshold=1,\n gt_points_drop=0.0,\n gt_drop_max_keep=10,\n remove_points_after_sample=True,\n anchor_cache=None,\n remove_environment=False,\n random_crop=False,\n reference_detections=None,\n out_size_factor=2,\n use_group_id=False,\n multi_gpu=False,\n min_points_in_gt=-1,\n random_flip_x=True,\n random_flip_y=True,\n sample_importance=1.0,\n out_dtype=np.float32):\n t = time.time()\n class_names = target_assigner.classes\n points = input_dict[\"lidar\"][\"points\"]\n indices = input_dict[\"lidar\"][\"indices\"]\n origins = input_dict[\"lidar\"][\"origins\"]\n if training:\n anno_dict = input_dict[\"lidar\"][\"annotations\"]\n gt_dict = {\n \"gt_boxes\": anno_dict[\"boxes\"],\n \"gt_names\": anno_dict[\"names\"],\n \"gt_importance\": np.ones([anno_dict[\"boxes\"].shape[0]], dtype=anno_dict[\"boxes\"].dtype),\n }\n if \"difficulty\" not in anno_dict:\n difficulty = np.zeros([anno_dict[\"boxes\"].shape[0]],\n dtype=np.int32)\n gt_dict[\"difficulty\"] = difficulty\n else:\n gt_dict[\"difficulty\"] = anno_dict[\"difficulty\"]\n if use_group_id and \"group_ids\" in anno_dict:\n group_ids = anno_dict[\"group_ids\"]\n gt_dict[\"group_ids\"] = group_ids\n calib = None\n if \"calib\" in input_dict:\n calib = input_dict[\"calib\"]\n\n # # Disable these two since we do not do this for NuScenes\n # if reference_detections is not None:\n # assert calib is not None and \"image\" in input_dict\n # C, R, T = box_np_ops.projection_matrix_to_CRT_kitti(P2)\n # frustums = box_np_ops.get_frustum_v2(reference_detections, C)\n # frustums -= T\n # frustums = np.einsum('ij, akj->aki', np.linalg.inv(R), frustums)\n # frustums = box_np_ops.camera_to_lidar(frustums, rect, Trv2c)\n # surfaces = box_np_ops.corner_to_surfaces_3d_jit(frustums)\n # masks = points_in_convex_polygon_3d_jit(points, surfaces)\n # points = points[masks.any(-1)]\n # if remove_outside_points:\n # assert calib is not None\n # image_shape = input_dict[\"image\"][\"image_shape\"]\n # points = box_np_ops.remove_outside_points(\n # points, calib[\"rect\"], calib[\"Trv2c\"], calib[\"P2\"], image_shape)\n\n # # Very interesting attempt\n # # I have tried the same and found it doesn't really work\n # if remove_environment is True and training:\n # selected = kitti.keep_arrays_by_name(gt_names, target_assigner.classes)\n # _dict_select(gt_dict, selected)\n # masks = box_np_ops.points_in_rbbox(points, gt_dict[\"gt_boxes\"])\n # points = points[masks.any(-1)]\n\n metrics = {}\n\n point_indices_to_remove = None\n if training:\n \"\"\"\n boxes_lidar = gt_dict[\"gt_boxes\"]\n bev_map = simplevis.nuscene_vis(points, boxes_lidar)\n cv2.imshow('pre-noise', bev_map)\n \"\"\"\n selected = kitti.drop_arrays_by_name(gt_dict[\"gt_names\"], [\"Denture\"])\n _dict_select(gt_dict, selected)\n if remove_unknown:\n remove_mask = gt_dict[\"difficulty\"] == -1\n \"\"\"\n gt_boxes_remove = gt_boxes[remove_mask]\n gt_boxes_remove[:, 3:6] += 0.25\n points = prep.remove_points_in_boxes(points, gt_boxes_remove)\n \"\"\"\n keep_mask = np.logical_not(remove_mask)\n _dict_select(gt_dict, keep_mask)\n gt_dict.pop(\"difficulty\")\n\n # This part is interesting - we will need to do the same\n if min_points_in_gt > 0:\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\"gt_boxes\"])\n mask = point_counts >= min_points_in_gt\n _dict_select(gt_dict, mask)\n\n gt_boxes_mask = np.array(\n [n in class_names for n in gt_dict[\"gt_names\"]], dtype=np.bool_)\n\n if db_sampler is not None:\n group_ids = None\n if \"group_ids\" in gt_dict:\n group_ids = gt_dict[\"group_ids\"]\n\n sampled_dict = db_sampler.sample_all(\n root_path,\n gt_dict[\"gt_boxes\"],\n gt_dict[\"gt_names\"],\n num_point_features,\n random_crop,\n gt_group_ids=group_ids,\n calib=calib)\n\n if sampled_dict is not None:\n sampled_gt_names = sampled_dict[\"gt_names\"]\n sampled_gt_boxes = sampled_dict[\"gt_boxes\"]\n sampled_points = sampled_dict[\"points\"]\n sampled_gt_masks = sampled_dict[\"gt_masks\"]\n gt_dict[\"gt_names\"] = np.concatenate(\n [gt_dict[\"gt_names\"], sampled_gt_names], axis=0)\n gt_dict[\"gt_boxes\"] = np.concatenate(\n [gt_dict[\"gt_boxes\"], sampled_gt_boxes])\n gt_boxes_mask = np.concatenate(\n [gt_boxes_mask, sampled_gt_masks], axis=0)\n sampled_gt_importance = np.full(\n [sampled_gt_boxes.shape[0]], sample_importance,\n dtype=sampled_gt_boxes.dtype)\n gt_dict[\"gt_importance\"] = np.concatenate(\n [gt_dict[\"gt_importance\"], sampled_gt_importance])\n\n if group_ids is not None:\n sampled_group_ids = sampled_dict[\"group_ids\"]\n gt_dict[\"group_ids\"] = np.concatenate(\n [gt_dict[\"group_ids\"], sampled_group_ids])\n\n # # Commented out because we have a new way of removing points\n # if remove_points_after_sample:\n # masks = box_np_ops.points_in_rbbox(points, sampled_gt_boxes)\n # point_indices_to_remove = np.flatnonzero(masks.any(-1))\n # # # Delay this process so we can use the full point cloud\n # # # when we do the ray stopping algorithm\n # # points = points[np.logical_not(masks.any(-1))]\n\n # # Paste objects behind so that we don't have to update indices\n # points = np.concatenate([sampled_points, points], axis=0)\n points = np.concatenate([points, sampled_points], axis=0)\n\n pc_range = voxel_generator.point_cloud_range\n group_ids = None\n if \"group_ids\" in gt_dict:\n group_ids = gt_dict[\"group_ids\"]\n\n # # Disable this one for now (not used in PointPillars anyways)\n # prep.noise_per_object_v3_(\n # gt_dict[\"gt_boxes\"],\n # points,\n # gt_boxes_mask,\n # rotation_perturb=gt_rotation_noise,\n # center_noise_std=gt_loc_noise_std,\n # global_random_rot_range=global_random_rot_range,\n # group_ids=group_ids,\n # num_try=100)\n\n # should remove unrelated objects after noise per object\n # for k, v in gt_dict.items():\n # print(k, v.shape)\n _dict_select(gt_dict, gt_boxes_mask)\n gt_classes = np.array(\n [class_names.index(n) + 1 for n in gt_dict[\"gt_names\"]],\n dtype=np.int32)\n gt_dict[\"gt_classes\"] = gt_classes\n gt_dict[\"gt_boxes\"], points, origins = prep.random_flip(\n gt_dict[\"gt_boxes\"], points, origins, 0.5, random_flip_x, random_flip_y)\n gt_dict[\"gt_boxes\"], points, origins = prep.global_rotation_v2(\n gt_dict[\"gt_boxes\"], points, origins, *global_rotation_noise)\n gt_dict[\"gt_boxes\"], points, origins = prep.global_scaling_v2(\n gt_dict[\"gt_boxes\"], points, origins, *global_scaling_noise)\n prep.global_translate_(\n gt_dict[\"gt_boxes\"], points, origins, global_translate_noise_std)\n bv_range = voxel_generator.point_cloud_range[[0, 1, 3, 4]]\n mask = prep.filter_gt_box_outside_range_by_center(gt_dict[\"gt_boxes\"], bv_range)\n _dict_select(gt_dict, mask)\n\n # limit rad to [-pi, pi]\n gt_dict[\"gt_boxes\"][:, 6] = box_np_ops.limit_period(\n gt_dict[\"gt_boxes\"][:, 6], offset=0.5, period=2 * np.pi)\n\n # boxes_lidar = gt_dict[\"gt_boxes\"]\n # bev_map = simplevis.nuscene_vis(points, boxes_lidar)\n # cv2.imshow('post-noise', bev_map)\n # cv2.waitKey(0)\n\n # # Disable this for now (not used in PointPillars anyways)\n # if shuffle_points:\n # # shuffle is a little slow.\n # np.random.shuffle(points)\n\n # [0, -40, -3, 70.4, 40, 1]\n voxel_size = voxel_generator.voxel_size\n pc_range = voxel_generator.point_cloud_range\n grid_size = voxel_generator.grid_size\n\n # organize points into lists based on timestamps\n time_stamps = points[indices[:-1], -1] # counting on the fact we do not miss points from any intermediate time_stamps\n time_stamps = (time_stamps[:-1]+time_stamps[1:])/2\n time_stamps = [-1000.0] + time_stamps.tolist() + [1000.0] # add boundaries\n time_stamps = np.array(time_stamps)\n\n # # LL_OCCUPIED, LL_FREE = 0.85, -0.4\n # lo_occupied = np.log(0.7 / (1 - 0.7))\n # lo_free = np.log(0.4 / (1 - 0.4))\n\n # is there are additional points (from database sampling)\n num_original = indices[-1]\n if len(points) > num_original:\n # split data into two half (indexed and un-indexed)\n original_points, sampled_points = points[:num_original], points[num_original:]\n # compute occupancy and masks\n # visibility, original_mask, sampled_mask = mapping.compute_visibility_and_masks(\n # original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size)\n # )\n logodds, original_mask, sampled_mask = mapping.compute_logodds_and_masks(\n original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size) # , lo_occupied, lo_free\n )\n # apply visible mask\n points = np.concatenate((original_points[original_mask], sampled_points[sampled_mask]))\n else:\n # visibility = mapping.compute_visibility(\n # points, origins, time_stamps, pc_range, min(voxel_size)\n # )\n logodds = mapping.compute_logodds(\n points, origins, time_stamps, pc_range, min(voxel_size) #, lo_occupied, lo_free\n )\n\n # T = len(time_stamps)-1\n # visibility = visibility.reshape(T, -1)\n # if T < (1 + max_sweeps):\n # visibility = np.pad(visibility, ((0, (1+max_sweeps)-T), (0,0)), 'edge')\n\n # with open(f'./utils/mapping/examples/{time.time()}.pkl', 'wb') as f:\n # ##\n # pickle.dump(original_points, f)\n # pickle.dump(sampled_points, f)\n # pickle.dump(origins, f)\n # pickle.dump(time_stamps, f)\n # pickle.dump(pc_range, f)\n # pickle.dump(voxel_size, f)\n # ##\n # pickle.dump(occupancy, f)\n # pickle.dump(original_mask, f)\n # pickle.dump(sampled_mask, f)\n\n if training:\n if min_points_in_gt > 0:\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\"gt_boxes\"])\n mask = point_counts >= min_points_in_gt\n _dict_select(gt_dict, mask)\n\n # [352, 400]\n t1 = time.time()\n if not multi_gpu:\n res = voxel_generator.generate(\n points, max_voxels)\n voxels = res[\"voxels\"]\n coordinates = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\n else:\n res = voxel_generator.generate_multi_gpu(\n points, max_voxels)\n voxels = res[\"voxels\"]\n coordinates = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([res[\"voxel_num\"]], dtype=np.int64)\n metrics[\"voxel_gene_time\"] = time.time() - t1\n example = {\n 'voxels': voxels,\n # 'visibility': visibility,\n 'logodds': logodds, \n 'num_points': num_points,\n 'coordinates': coordinates,\n \"num_voxels\": num_voxels,\n \"metrics\": metrics,\n }\n if calib is not None:\n example[\"calib\"] = calib\n feature_map_size = grid_size[:2] // out_size_factor\n feature_map_size = [*feature_map_size, 1][::-1]\n # print(f'feature_map_size in prep_pointcloud(): {feature_map_size}')\n if anchor_cache is not None:\n # print('having anchor cache')\n anchors = anchor_cache[\"anchors\"]\n anchors_bv = anchor_cache[\"anchors_bv\"]\n anchors_dict = anchor_cache[\"anchors_dict\"]\n matched_thresholds = anchor_cache[\"matched_thresholds\"]\n unmatched_thresholds = anchor_cache[\"unmatched_thresholds\"]\n\n else:\n # print('NOT having anchor cache')\n ret = target_assigner.generate_anchors(feature_map_size)\n anchors = ret[\"anchors\"]\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\n anchors_bv = box_np_ops.rbbox2d_to_near_bbox(\n anchors[:, [0, 1, 3, 4, 6]])\n matched_thresholds = ret[\"matched_thresholds\"]\n unmatched_thresholds = ret[\"unmatched_thresholds\"]\n # print(f'anchors.shape: {anchors.shape}')\n\n example[\"anchors\"] = anchors\n anchors_mask = None\n if anchor_area_threshold >= 0:\n # slow with high resolution. recommend disable this forever.\n coors = coordinates\n dense_voxel_map = box_np_ops.sparse_sum_for_anchors_mask(\n coors, tuple(grid_size[::-1][1:]))\n dense_voxel_map = dense_voxel_map.cumsum(0)\n dense_voxel_map = dense_voxel_map.cumsum(1)\n anchors_area = box_np_ops.fused_get_anchors_area(\n dense_voxel_map, anchors_bv, voxel_size, pc_range, grid_size)\n anchors_mask = anchors_area > anchor_area_threshold\n # example['anchors_mask'] = anchors_mask.astype(np.uint8)\n example['anchors_mask'] = anchors_mask\n # print(\"prep time\", time.time() - t)\n metrics[\"prep_time\"] = time.time() - t\n if not training:\n return example\n example[\"gt_names\"] = gt_dict[\"gt_names\"]\n # voxel_labels = box_np_ops.assign_label_to_voxel(gt_boxes, coordinates,\n # voxel_size, coors_range)\n if create_targets:\n t1 = time.time()\n targets_dict = target_assigner.assign(\n anchors,\n anchors_dict,\n gt_dict[\"gt_boxes\"],\n anchors_mask,\n gt_classes=gt_dict[\"gt_classes\"],\n gt_names=gt_dict[\"gt_names\"],\n matched_thresholds=matched_thresholds,\n unmatched_thresholds=unmatched_thresholds,\n importance=gt_dict[\"gt_importance\"])\n\n \"\"\"\n boxes_lidar = gt_dict[\"gt_boxes\"]\n bev_map = simplevis.nuscene_vis(points, boxes_lidar, gt_dict[\"gt_names\"])\n assigned_anchors = anchors[targets_dict['labels'] > 0]\n ignored_anchors = anchors[targets_dict['labels'] == -1]\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], ignored_anchors, [128, 128, 128], 2)\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], assigned_anchors, [255, 0, 0])\n cv2.imshow('anchors', bev_map)\n cv2.waitKey(0)\n\n boxes_lidar = gt_dict[\"gt_boxes\"]\n pp_map = np.zeros(grid_size[:2], dtype=np.float32)\n voxels_max = np.max(voxels[:, :, 2], axis=1, keepdims=False)\n voxels_min = np.min(voxels[:, :, 2], axis=1, keepdims=False)\n voxels_height = voxels_max - voxels_min\n voxels_height = np.minimum(voxels_height, 4)\n # sns.distplot(voxels_height)\n # plt.show()\n pp_map[coordinates[:, 1], coordinates[:, 2]] = voxels_height / 4\n pp_map = (pp_map * 255).astype(np.uint8)\n pp_map = cv2.cvtColor(pp_map, cv2.COLOR_GRAY2RGB)\n pp_map = simplevis.draw_box_in_bev(pp_map, [-50, -50, 3, 50, 50, 1], boxes_lidar, [128, 0, 128], 1)\n cv2.imshow('heights', pp_map)\n cv2.waitKey(0)\n \"\"\"\n example.update({\n 'labels': targets_dict['labels'],\n 'reg_targets': targets_dict['bbox_targets'],\n # 'reg_weights': targets_dict['bbox_outside_weights'],\n 'importance': targets_dict['importance'],\n })\n return example","def randomize(self):\n\t\tif self.hasRandomizedAmplitudes:\n\t\t\tself.unrandomize()\n\t\tself.randoms = np.random.multivariate_normal(np.zeros((2*self.totalBins)), self.coma)\n\t\tfor i in range(self.totalBins):\n\t\t\tself.reals[i] += self.randoms[2*i ]\n\t\t\tself.imags[i] += self.randoms[2*i+1]\n\t\tself.hasRandomizedAmplitudes = True","def reset(self):\n self.x = random.uniform(-0.05, 0.05)\n self.x_dot = random.uniform(-0.05, 0.05)\n self.theta = random.uniform(-0.05, 0.05)\n self.theta_dot = random.uniform(-0.05, 0.05)","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def elapseTime(self, gameState):\n newParticleList = []\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\n # likely the ghost is to move to that position\n for particle in self.particles:\n newPosDist = self.getPositionDistribution(gameState, particle)\n newParticleList.append(util.sample(newPosDist))\n self.particles = newParticleList","def mutate_point_poly(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 3: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def JitterPoints(points, sigma=0.01): \n C = 3\n assert(points.shape[1] == C)\n\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\n return points + randJitters","def MovePoint(pos,points,s=0.5, k = 1000): \n \n x = [pos[0]] \n y = [pos[1]]\n rdm.seed(1) # comment out if you want randomness\n for i in range(k):\n n = len(points)\n r = int(rdm.random()*n)\n \n x.append(x[i] + (points[r][0] - x[i]) * s)\n y.append(y[i] + (points[r][1] - y[i]) * s)\n\n \n return(x,y)","def test_rotating_phantom(self):\n cheese = TomoCheese.from_demo_images()\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\n for img in cheese.dicom_stack:\n img.array = rotate(img.array, angle=3, mode=\"edge\")\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def random_translation(canvas, img):","def _sample_z(self, a):\n r = np.random.rand()\n return ((1 + r * (a - 1))**2) / a","def _get_random_transform(self, img_shape, seed=None):\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if self.rotation_range:\n theta = np.random.uniform(\n -self.rotation_range,\n self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n try: # 1-D array-like or int\n tx = np.random.choice(self.height_shift_range)\n tx *= np.random.choice([-1, 1])\n except ValueError: # floating point\n tx = np.random.uniform(-self.height_shift_range,\n self.height_shift_range)\n if np.max(self.height_shift_range) < 1:\n tx *= img_shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n try: # 1-D array-like or int\n ty = np.random.choice(self.width_shift_range)\n ty *= np.random.choice([-1, 1])\n except ValueError: # floating point\n ty = np.random.uniform(-self.width_shift_range,\n self.width_shift_range)\n if np.max(self.width_shift_range) < 1:\n ty *= img_shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(\n -self.shear_range,\n self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(\n self.zoom_range[0],\n self.zoom_range[1],\n 2)\n\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\n\n channel_shift_intensity = None\n if self.channel_shift_range != 0:\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\n self.channel_shift_range)\n\n brightness = None\n if self.brightness_range is not None:\n brightness = np.random.uniform(self.brightness_range[0],\n self.brightness_range[1])\n\n transform_parameters = {'theta': theta,\n 'tx': tx,\n 'ty': ty,\n 'shear': shear,\n 'zx': zx,\n 'zy': zy,\n 'flip_horizontal': flip_horizontal,\n 'flip_vertical': flip_vertical,\n 'channel_shift_intensity': channel_shift_intensity,\n 'brightness': brightness}\n\n return transform_parameters","def mutate_point_rect(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_rect(mutated_genome,index)\n else: #seed == 1:\n shift_point_rect(mutated_genome,index)","def randomize(self):\n #first take care of all parameters (from N(0,1))\n x = self._get_params_transformed()\n x = np.random.randn(x.size)\n self._set_params_transformed(x)\n #now draw from prior where possible\n x = self._get_params()\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\n self._set_params(x)\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)","def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\n def genPos():\n r = radius_scale * self.np_random.rand() + radius_offset\n a = -np.pi * angle_scale + angle_offset\n b = np.pi * angle_scale + angle_offset\n ang = (b - a) * self.np_random.rand() + a\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\n def isNear(pos, poss):\n for p, o in poss:\n if np.linalg.norm(p - pos) < near_distance:\n return True\n return False\n def genPosRetry(poss):\n for i in range(retry):\n pos = genPos()\n if not isNear(pos, poss):\n return pos\n return genPos()\n poss = []\n for i in range(num):\n pos = genPosRetry(poss)\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\n poss.append((pos, orn))\n self.np_random.shuffle(poss)\n return poss","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def random_plane_points(num_points, bounds):\n\n # Infer dimension of data from bounds\n (bounds, dimension) = infer_dimension(bounds)\n\n # Generate points and rescale to fit bounds\n points = np.random.rand(num_points, dimension)\n unit_mean = [0.5] * dimension\n shifted_points = points - unit_mean + bounds.mean(axis=1)\n scale = bounds[:, 1] - bounds[:, 0]\n rescaled_points = np.dot(shifted_points, np.diag(scale))\n\n return rescaled_points","def randTheta(k, scale=1):\n return generatePoints(1, k, scale=scale)[0].reshape((k + 1, -1))","def totem_random():\n random_head()\n random_head()\n random_head()","def random_transform(self, x):\n pass","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def cointoss():\n return random.random() < 0.5","def repick(g1_x, g1_y, g1_z):\n i = random.randint(0, len(g1_x) - 1)\n x = g1_x[i]\n y = g1_y[i]\n z = g1_z[i]\n return x, y, z","def randomizePlayerPose(transform, arena_radius=8):\n initial_r = arena_radius * random.random()\n initial_theta = 2 * math.pi * random.random()\n initial_x = initial_r * math.cos(initial_theta)\n initial_y = initial_r * math.sin(initial_theta)\n initial_rotation = 2 * math.pi * random.random()\n transform.translation.x = initial_x\n transform.translation.y = initial_y\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])","def resample(self):\n self.X = np.random.uniform(-1, 1, (100, 2))\n self.generate_y()\n self.phi = None\n self.K = 0\n self.centers = None\n self.cluster_sizes = None\n self.g = None\n self.gamma = None","def __call__(self, results):\n if np.random.rand() > self.prob:\n return results\n h, w = results['image'].shape[:2]\n center = self.center\n if center is None:\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\n angle = random_negative(self.angle, self.random_negative_prob)\n self._rotate_img(results, angle, center, self.scale)\n return results","def move(self):\n if self._z >= 75:\n a = random.random()\n print(str(a))\n if a < 0.2:\n self._z += 1\n if a > 0.2 and a < 0.9:\n self._z -= 1\n if a > 0.9:\n self._z = self._z\n else: \n self._z -= 1\n \n b = random.random()\n print(str(b))\n if b < 0.1:\n self._y += 1\n if b > 0.1 and b < 0.2:\n self._y -= 1\n if b > 0.2 and b < 0.25:\n self._x -= 1\n if b > 0.25:\n self._x += 1","def random_sample(grid_size):\r\n g = grid_size\r\n x_range = g[1] - g[0]\r\n\r\n y_range = g[3] - g[2]\r\n\r\n x_off = g[0]\r\n y_off = g[2]\r\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \r\n return (x,y)","def generate_random_DC_crack_coupled_tensor():\n # 1. Generate random DC MT and crack MT:\n # generate DC MT:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\n # Get between small range:\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\n random_num = random.random()\n if random_num <= 0.5:\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\n elif random_num > 0.5:\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n # And redistribute evenly everywhere on boundary:\n random_num = random.random()\n if random_num>0.25 and random_num<=0.5:\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\n if random_num>0.5 and random_num<=0.75:\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\n if random_num>0.75 and random_num<=1.0:\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\n # --- ---\n # random_num = random.random()\n # if random_num <= 0.5:\n # theta_lune_sphere = random.random()*np.pi/2.\n # elif random_num > 0.5:\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\n # random_num = random.random()\n # if random_num <= 0.5:\n # phi_lune_sphere = np.pi/6.\n # elif random_num > 0.5:\n # phi_lune_sphere = -1.*np.pi/6.\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\n # 2. Combine DC and crack tensors:\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\n # 3. Randomly rotate DC-crack MT to random orientation:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\n # 4. Normalise and get 6 MT:\n # Get 6 MT:\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\n # And normallise so that moment tensor magnitude = 1:\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\n return DC_crack_six_MT_rotated_normalised, random_amp_frac","def shift_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def get_random_translations(atom_pos, beam_focus_size, jet_radius):\n N = len(atom_pos)\n beam_focus_radius = beam_focus_size/2\n flag = True\n while(flag):\n x_trans = beam_focus_radius*np.random.uniform(-1, 1)\n y_trans = beam_focus_radius*np.random.uniform(-1, 1)\n z_trans = jet_radius*np.random.uniform(-1, 1)\n trans = [[x_trans, y_trans, z_trans]]*N\n trans = np.asarray(trans)\n new_pos = atom_pos + trans\n print (\"trans_new_pos\", new_pos)\n for i in range(N):\n if (np.sqrt(new_pos[i][0]**2 + new_pos[i][1]**2) >= beam_focus_radius):\n flag = False\n break\n else:\n flag = False\n return new_pos","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def aecSpaceRandomTowers():\n origin = aecPoint(0, 0, 0)\n displace = 175\n spacer = aecSpacer()\n shaper = aecShaper()\n \n def full(point, xWidth, yDepth, zHeight, level):\n floor = aecSpace()\n floor.boundary = shaper.makeBox(point, xWidth, yDepth)\n floor.height = zHeight\n floor.level = level\n setColors([floor])\n return [floor]\n \n def halfDepth(point, xWidth, yDepth, zHeight, level):\n depth = yDepth * 0.5\n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, xWidth, depth)\n half1.height = zHeight\n half1.level = level\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\n setColors(halfSpaces)\n return halfSpaces\n \n def halfWidth(point, xWidth, yDepth, zHeight, level):\n width = xWidth * 0.5\n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, width, yDepth)\n half1.height = zHeight\n half1.level = level\n halfSpaces = [half1] + spacer.row(half1)\n setColors(halfSpaces)\n return halfSpaces\n \n def quarterDepth(point, xWidth, yDepth, zHeight, level):\n if randint(0, 1) == 0:\n depth = yDepth * 0.25\n scale = 3\n else:\n depth = yDepth * 0.75\n scale = 0.333333333 \n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, xWidth, depth)\n half1.height = zHeight\n half1.level = level \n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\n halfSpaces[1].scale(1, scale, 1, halfSpaces[1].points_floor[0])\n setColors(halfSpaces)\n return halfSpaces\n \n def quarterWidth(point, xWidth, yDepth, zHeight, level):\n if randint(0, 1) == 0:\n width = xWidth * 0.25\n scale = 3\n else:\n width = xWidth * 0.75\n scale = 0.333333333 \n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, width, yDepth)\n half1.height = zHeight\n half1.level = level \n halfSpaces = [half1] + spacer.row(half1)\n halfSpaces[1].scale(scale, 1, 1, halfSpaces[1].points_floor[0])\n setColors(halfSpaces)\n return halfSpaces\n \n def setColors(halfSpaces):\n colors = [aecColor.blue, aecColor.orange, aecColor.purple, aecColor.yellow]\n colorPick = randint(0, 3)\n halfSpaces[0].color = colors[colorPick]\n if len(halfSpaces) == 1: return\n colors.reverse()\n halfSpaces[1].color = colors[colorPick]\n \n def makeFloor(point, xWidth, yDepth, zHeight, level):\n floorType = randint(0, 4)\n if floorType == 0: floorSpaces = full(point, xWidth, yDepth, zHeight, level)\n if floorType == 1: floorSpaces = halfDepth(point, xWidth, yDepth, zHeight, level)\n if floorType == 2: floorSpaces = halfWidth(point, xWidth, yDepth, zHeight, level)\n if floorType == 3: floorSpaces = quarterDepth(point, xWidth, yDepth, zHeight, level)\n if floorType == 4: floorSpaces = quarterWidth(point, xWidth, yDepth, zHeight, level)\n return floorSpaces\n \n def makeCore(point, xWidth, yDepth, zHeight): \n xCoord = (point.x - 5) + (xWidth * 0.5)\n yCoord = (point.y + (yDepth * (randint(0, 9) * 0.1)))\n point = aecPoint(xCoord, yCoord, point.z)\n core = aecSpace()\n core.boundary = shaper.makeBox(point, 10, 20)\n core.height = zHeight\n core.color = aecColor.gray\n return [core]\n \n def makeTower(point):\n floors = []\n xWidth = uniform(20, 60)\n yDepth = uniform(20, 60)\n levels = randint(5, 50)\n zHeight = uniform(3, 6)\n plinth = aecSpace()\n plinth.boundary = shaper.makeBox(point, xWidth, yDepth)\n plinthScaleX = (uniform(1, 2.5))\n plinthScaleY = (uniform(1, 2.5))\n plinth.scale(plinthScaleX, plinthScaleY, 2, plinth.centroid_floor)\n plinth.height = (zHeight * 2)\n plinth.color = aecColor.green\n floors.append(plinth)\n floors = floors + makeCore(point, xWidth, yDepth, zHeight * (levels + 3))\n level = (zHeight * 2)\n x = 0\n while x < levels:\n floors = floors + makeFloor(point, xWidth, yDepth, zHeight, level)\n level += zHeight\n x += 1 \n return floors\n \n def makeTowerRow(point, columns, displacement):\n towers = []\n towers = towers + makeTower(point)\n x = 0\n while x < columns:\n point.x += displacement\n towers = towers + makeTower(point)\n x += 1\n return towers\n \n def makeTowerRows(point, displacement, columns, rows):\n towers = []\n x = 0\n while x < rows:\n towers = towers + makeTowerRow(point, columns, displacement)\n point.x = 0\n point.y += displacement\n x += 1\n return towers\n \n return makeTowerRows(origin, displace, 4, 5)","def sample_preimage(self, point, seed=None):\r\n [[a, b], [c, d]] = self.B0_fft\r\n\r\n # We compute a vector t_fft such that:\r\n # (fft(point), fft(0)) * B0_fft = t_fft\r\n # Because fft(0) = 0 and the inverse of B has a very specific form,\r\n # we can do several optimizations.\r\n '''\r\n print(\"---------Inside sample_preimage----------\")\r\n print(\"point: \", point)\r\n '''\r\n\r\n point_fft = fft(point)\r\n\r\n t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]\r\n t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]\r\n t_fft = [t0_fft, t1_fft]\r\n\r\n # We now compute v such that:\r\n # v = z * B0 for an integral vector z\r\n # v is close to (point, 0)\r\n if seed is None:\r\n # If no seed is defined, use urandom as the pseudo-random source.\r\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)\r\n\r\n else:\r\n # If a seed is defined, initialize a ChaCha20 PRG\r\n # that is used to generate pseudo-randomness.\r\n chacha_prng = ChaCha20(seed)\r\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,\r\n chacha_prng.randombytes)\r\n\r\n v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))\r\n v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))\r\n v0 = [int(round(elt)) for elt in ifft(v0_fft)]\r\n v1 = [int(round(elt)) for elt in ifft(v1_fft)]\r\n\r\n # The difference s = (point, 0) - v is such that:\r\n # s is short\r\n # s[0] + s[1] * h = point\r\n s = [sub(point, v0), neg(v1)]\r\n return s","def random():\n np.random.seed(0)","def modify_pt(pt=None,):\n global dim\n mod_rand_pt = []\n\n for i_ in range(dim):\n for j_ in range(i_, dim):\n mod_rand_pt.append(pt[i_] * pt[j_])\n\n mod_rand_pt.append(1.)\n return mod_rand_pt","def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]]) # rotate along y axis\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\n return rotated_data","def remove_point(mutated_genome,index):\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n del mutated_genome[index][2][point_index]","def move_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\n point = (Xval,Yval)\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n mutated_genome[index][2][point_index] = point","def rand_raster(center, step_size, num_points, random):\n xscan = []\n yscan = []\n \n xcenter = center[0] # first element of center array\n ycenter = center[1] # second element of center array\n \n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\n \n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n \n # Creates two arrays xscan and yscan\n for step, ystep in enumerate(yrange):\n xscan.append(xrange[::(-1)**step])\n yscan.append(np.ones_like(xrange) * ystep)\n \n xscan = np.concatenate(xscan)\n yscan = np.concatenate(yscan)\n \n # Combine the two arrays into a list of vectors\n raster = []\n \n for i in range(0, len(xscan)):\n scan_element = []\n \n scan_element.append(xscan[i])\n scan_element.append(yscan[i])\n raster.append(scan_element)\n \n return raster","def generate(random, lower, upper, count=1):\n if count > 1:\n points = []\n\n for x in range(lower.x, upper.x):\n for y in range(lower.y, upper.y):\n points.append(Point(x, y)) # REFACTOR: Not very efficient\n\n return random.sample(points, count)\n else:\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))","def _sample_using_random(\n self,\n p: float = 0.1,\n ):\n return sa.func.random() < p","def random_transform(self, x, seed=None):\n # x is a single audio, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\n input_length = x.shape[img_row_axis]\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\n if x.shape[img_row_axis] >= input_length:\n x = x[:input_length]\n else:\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\n 'constant', constant_values=(0, np.mean(x)))\n\n if shift:\n hx = np.random.uniform(-self.shift, self.shift)\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\n\n if self.roll_range:\n tx = np.random.uniform(-self.roll_range, self.roll_range)\n if self.roll_range < 1:\n tx *= x.shape[img_row_axis]\n x = np.roll(x, int(tx), axis=(img_row_axis))\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = np.flip(x, axis=img_row_axis)\n\n if (self.noise):\n if np.random.random() < 0.5:\n if self.noise[-1] == 'Uniform':\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\n elif self.noise[-1] == 'Normal':\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\n\n if self.brightness_range is not None:\n x = random_brightness(x, self.brightness_range)\n\n return x","def get_transforms(partition: str, num_points: int = 1024,\n noise_type: str = 'clean', rot_mag: float = 45.0,\n trans_mag: float = 0.5, partial_p_keep: List = None):\n\n partial_p_keep = partial_p_keep if partial_p_keep is not None else [0.7, 0.7]\n\n if noise_type == \"clean\":\n # 1-1 correspondence for each point (resample first before splitting), no noise\n if partition == 'train':\n transforms = [Transforms.Resampler(num_points),\n Transforms.SplitSourceRef(),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetDeterministic(),\n Transforms.FixedResampler(num_points),\n Transforms.SplitSourceRef(),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"jitter\":\n # Points randomly sampled (might not have perfect correspondence), gaussian noise to position\n if partition == 'train':\n transforms = [Transforms.SetJitterFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetJitterFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"crop\":\n # Both source and reference point clouds cropped, plus same noise in \"jitter\"\n if partition == 'train':\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCrop(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCrop(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"cropinv\":\n # Both source and reference point clouds cropped, plus same noise in \"jitter\"\n if partition == 'train':\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCropinv(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCropinv(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n raise NotImplementedError\n\n return transforms","def randomize(self):\r\n # first take care of all parameters (from N(0,1))\r\n x = self._get_params_transformed()\r\n x = np.random.randn(x.size)\r\n self._set_params_transformed(x)\r\n # now draw from prior where possible\r\n x = self._get_params()\r\n if self.priors is not None:\r\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\r\n self._set_params(x)\r\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\r","def flip(p=0.5):\n return np.random.random() < p","def image_rotate(Xb, batch_size):\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\n delta = 30. * intensity # scale by self.intensity\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\n return Xb","def reset(self):\n newPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\n self.pot = np.asarray(newPerm)","def augmenter(x, y):\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\n # as 3D microscopy acquisitions are usually not axially symmetric\n x, y = random_fliprot(x, y, axis=(1, 2))\n x = random_intensity_change(x)\n return x, y","def unforeseen():\r\n return random.gauss(300., 100.)","def rotate_point_cloud_in_plane(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, -sinval, 0],\n [sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def random():\n np.random.seed(1939)","def randomize(self, amplitude):\n from random import gauss\n # update alignment from projections\n self.getMarkersFromTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\n\n # add random amplitude\n # markers\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\n for (imark, mark) in enumerate(self._Markers):\n if (imark + 1) != irefmark:\n r = mark.get_r()\n for ii in range(0, 3):\n r[ii] = gauss(0, amplitude) + r[ii]\n self._Markers[imark].set_r(r)\n\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\n # translations, rotations, magnifications\n for itilt in range(0, self._ntilt):\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\n if (self._projIndices[itilt] != ireftilt):\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\n\n # update alignment from projections\n self.setMarkersInTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)","def sample_from_belief(self):\n if self._use_information_bottleneck:\n posteriors = [torch.distributions.Normal(m, torch.sqrt(s)) for m, s in zip(torch.unbind(self.z_means), torch.unbind(self.z_vars))]\n z = [d.rsample() for d in posteriors]\n self.z = torch.stack(z)\n else:\n self.z = self.z_means","def rndSphere():\n sph = [0,0,0]\n \n sph[2] = random.uniform(-1.0,1.0)\n z2 = math.sqrt(1.0 - sph[2]*sph[2])\n phi = (2. * math.pi) * random.random()\n sph[0] = z2 * math.cos(phi)\n sph[1] = z2 * math.sin(phi)\n \n return sph","def importance_sampling_step(self, positions, analytic):\n \"\"\"With upgrad method for suggetion of new positions.\"\"\"\n \"\"\"Given through the Langevin equation.\n D is the diffusion coefficient equal 0.5, xi is a gaussion random\n variable and delta_t is the time step between 0.001 and 0.01\"\"\"\n\n D = 0.5\n greens_function = 0.0\n\n if analytic == True:\n F_old = self.w.quantum_force(positions)\n else:\n F_old = self.w.quantum_force_numerical(positions)\n\n # r = random.random()*random.choice((-1, 1))\n # r = np.random.normal()\n r = np.zeros(self.num_d)\n for i in range(self.num_d):\n r[i] = random.gauss(0, 1)\n # Pick a random particle and calculate new position\n random_index = random.randrange(len(positions))\n new_positions = np.array(positions)\n\n term1 = D*F_old[random_index, :]*self.delta_t\n term2 = r*np.sqrt(self.delta_t)\n new_random_position = new_positions[random_index, :] + term1 + term2\n new_positions[random_index, :] = new_random_position\n\n # Check if wave function is zero\n test_wavefunction = self.w.wavefunction(new_positions)\n if test_wavefunction**2 <= 1e-14:\n pass\n else:\n prob_ratio = self.w.wavefunction_ratio(positions, new_positions)\n\n if analytic == True:\n F_new = self.w.quantum_force(new_positions)\n else:\n F_new = self.w.quantum_force_numerical(new_positions)\n\n for i in range(self.num_p):\n for j in range(self.num_d):\n term1 = 0.5*((F_old[i, j] + F_new[i, j]) *\n (positions[i, j] - new_positions[i, j]))\n term2 = D*self.delta_t*(F_old[i, j] - F_new[i, j])\n greens_function += term1 + term2\n\n greens_function = np.exp(greens_function)\n\n epsilon = np.random.sample()\n acceptance_ratio = prob_ratio*greens_function\n\n if acceptance_ratio > epsilon:\n positions = new_positions\n self.s.distances_update(positions, random_index)\n self.c += 1.0\n\n else:\n pass\n\n return positions","def Generate_Random( self ):\n print( 'Generating Random coordinates' )\n stands = self.Data.Stand.keys()\n stands.sort()\n for s in stands:\n trees = self.Data.Stand[s].Tree.keys()\n trees.sort()\n for t in trees:\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )","def test_randoms():\n\n # generate two locusts of points\n npts = 200\n epsilon = 0.3\n # #cluster 1\n coords1 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\n coords2 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\n\n # generate orientation vectors for cluster 1\n vectors1 = normalized_vectors(np.random.random((npts, 3)) * 2.0 - 1.0)\n\n # define radial bins\n rbins = np.array([0.0, 0.1, 2.0 * epsilon])\n s = np.zeros((npts, 3))\n\n s[:, 0] = coords2[:, 0] - coords1[:, 0]\n s[:, 1] = coords2[:, 1] - coords1[:, 1]\n s[:, 2] = coords2[:, 2] - coords1[:, 2]\n\n dist_a = s[:, 0] ** 2 + s[:, 1] ** 2 + s[:, 2] ** 2\n\n # define weights appropiate for weighting function\n weights1 = np.ones((npts, 4))\n weights1[:, 1] = vectors1[:, 0]\n weights1[:, 2] = vectors1[:, 1]\n weights1[:, 3] = vectors1[:, 2]\n weights2 = np.ones(npts)\n\n # weighting 1\n # calculate weighted counts\n weighted_counts, counts = positional_marked_npairs_3d(\n coords1,\n coords2,\n rbins,\n period=None,\n weights1=weights1,\n weights2=weights2,\n weight_func_id=1,\n num_threads=1,\n )\n\n msg = (\n \"weighted counts do not match expected result given the weighting function\"\n + \" \"\n + str(np.max(dist_a))\n )\n assert np.isclose(weighted_counts[-1], 0.0 * counts[-1], atol=4000), msg","def generate(self) -> np.ndarray:\n self.sample_r()\n self.sample_z()\n ind: np.ndarray = np.less_equal(self.z_sample, self.r_sample)\n self.r_sample = self.r_sample[ind]\n self.z_sample = self.z_sample[ind]\n return np.sort(np.sqrt(np.subtract(np.square(self.r_sample), np.square(self.z_sample))))"],"string":"[\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def random_rotation(self, img, p = 0.5):\\n if self.decision(p):\\n theta = random.randrange(-15, 15)\\n phi = random.randrange(-15, 15)\\n gamma = random.randrange(-15, 15)\\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\\n # check if cut is ahve to much dark pixels, more then 20 %\\n non_zeros = np.count_nonzero(roi)\\n non_zeros_procent = non_zeros / roi.size\\n if non_zeros_procent < 0.8:\\n pass\\n else:\\n img = roi\\n return img\",\n \"def rotate_point_cloud(data):\\n rotated_data = np.zeros(data.shape, dtype=np.float32)\\n for k in xrange(data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\\n ## https://en.wikipedia.org/wiki/Rotation_matrix\\n if(use_rotation_tensor != True):\\n angle_range = DEGREES\\n x_angle = radians(random.random() * angle_range)\\n y_angle = radians(random.random() * angle_range)\\n z_angle = radians(random.random() * angle_range)\\n\\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\\n rotation_matrix = torch.mm(rot_y, rot_z)\\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \\n\\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n \\n \\n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\\n self.rotation_matrix = rotation_matrix\\n \\n if(save_rotation_tensor):\\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \\n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\\n else: \\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\\n return pointcloud_model_rotated[:,:,0:3]\",\n \"def augment_cloud(Ps):\\n \\\"Augmented params:\\\"\\n pc_augm_scale=0\\n pc_augm_rot=1\\n pc_augm_mirror_prob=0.5\\n pc_augm_jitter=0\\n\\n M = transforms3d.zooms.zfdir2mat(1)\\n if pc_augm_scale > 1:\\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\\n if pc_augm_rot:\\n angle = random.uniform(0, 2*math.pi)\\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\\n result = []\\n for P in Ps:\\n P[:,:3] = np.dot(P[:,:3], M.T)\\n\\n if pc_augm_jitter:\\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\\n result.append(P)\\n return result\",\n \"def randomPointOnSphere(r):\\n x = np.random.normal()\\n y = np.random.normal()\\n z = np.random.normal()\\n point = np.array([x, y, z])\\n point *= r/(x**2 + y**2 + z**2)**.5\\n return point\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def randomize_trajectory(self):\\n self.angle = randint(-360, 360)\\n self.speed = randint(1, 5)/2.5\",\n \"def rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def resample_particles(self):\\n # make sure the distribution is normalized\\n self.normalize_particles()\\n\\n newParticles = []\\n for i in range(len(self.particle_cloud)):\\n # resample the same # of particles\\n choice = random_sample()\\n # all the particle weights sum to 1\\n csum = 0 # cumulative sum\\n for particle in self.particle_cloud:\\n csum += particle.w\\n if csum >= choice:\\n # if the random choice fell within the particle's weight\\n newParticles.append(deepcopy(particle))\\n break\\n self.particle_cloud = newParticles\",\n \"def _sample_k_new(self, cur_y, cur_z):\\n N = float(len(self.obs))\\n #old_loglik = self._loglik(cur_y, cur_z)\\n\\n k_new_count = np.random.poisson(self.alpha / N)\\n if k_new_count == 0: return False\\n \\n # modify the feature ownership matrix\\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\\n # propose feature images by sampling from the prior distribution\\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\\n \\n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def reroll(self):\\n self._base_x = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._x_min,\\n self.base_point_distribution._x_max\\n )\\n self._base_y = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._y_min,\\n self.base_point_distribution._y_max\\n )\",\n \"def mutate(self, size):\\n rand = random.random()\\n if rand <= 0.5:\\n print u\\\"changing colour\\\"\\n idx = random.randrange(0, 4)\\n value = random.randrange(0, 256)\\n colour = list(self.colour)\\n colour[idx] = value\\n self.colour = tuple(colour)\\n else:\\n print u\\\"changing point\\\"\\n idx = random.randrange(0, len(self.points))\\n point = generate_point(size[0], size[1])\\n self.points[idx] = point\",\n \"def mutate_point_poly3(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def random_rotate(self):\\r\\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\\r\\n flip = rand.randrange(0, 2, 1) # 0, 1\\r\\n new_seed = copy.deepcopy(self)\\r\\n # rotate by 90 degrees * rotation (0, 90, 180 270)\\r\\n new_seed.cells = np.rot90(new_seed.cells, rotation) \\r\\n if (flip == 1):\\r\\n # flip upside down\\r\\n new_seed.cells = np.flipud(new_seed.cells)\\r\\n new_seed.xspan = new_seed.cells.shape[0]\\r\\n new_seed.yspan = new_seed.cells.shape[1]\\r\\n return new_seed\",\n \"def spread_quaternions(points,num=100,quats_per_step=100):\\n quats = np.zeros((num,4))\\n rot_points = np.zeros((num,points.shape[0],3))\\n quats[0,:] = [0,0,0,1]\\n rot_points[0,:,:] = points\\n for ix in range(1,num):\\n rand_quats = random_quaternions(quats_per_step) \\n positioned = rotate_points(points,rand_quats) \\n dists = point_dists(rot_points[:ix],positioned)\\n new_rot = np.argmax(dists) \\n quats[ix,:]=rand_quats[new_rot,:]\\n rot_points[ix,:,:] = positioned[new_rot,:,:]\\n \\n return quats,rot_points\",\n \"def _sample_lam(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_lam = self.lam\\n \\n # modify the feature ownership matrix\\n self.lam = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.lam = old_lam\",\n \"def initialise_particle_cloud(self, initialpose):\\n # ----- Initialize the particle cloud as an empty array\\n self.particlecloud = PoseArray()\\n\\n \\\"\\\"\\\"Create the noise to multiply by the random Gaussian number that will\\n get added to each of the Poses, that are set to a random position\\n and orientation around the initial pose\\\"\\\"\\\"\\n sensorSigma=3 #variance\\n sensorMu=0 #mean\\n noise=sensorSigma * numpy.random.randn() + sensorMu\\n\\n \\\"\\\"\\\"Create a range for the ammount of random Gaussian values to generate \\\"\\\"\\\"\\n randomGauss = 10*self.NUMBER_PREDICTED_READINGS\\n\\n gaussianRandomNumX = []\\n gaussianRandomNumY = []\\n randomYawArray = []\\n\\n for i in range (0,randomGauss):\\n gaussianRandomNumX.append(random.gauss(0,1))\\n gaussianRandomNumY.append(random.gauss(0,1))\\n x=random.randint(1,180)\\n randomYaw=(math.pi/x)\\n randomYawArray.append(randomYaw)\\n\\n iterator = 0\\n\\n \\\"\\\"\\\"\\n\\t Set the particles to a random position and orientation around the initial pose\\n \\\"\\\"\\\"\\n particleNumber = 10**2 # 10**3 # 10**4 # 10**5 experiment with different ammounts of particles\\n\\n while iterator < particleNumber:\\n particle = Pose()\\n particle.position.x = initialpose.pose.pose.position.x + (gaussianRandomNumX[iterator] * noise)\\n particle.position.y = initialpose.pose.pose.position.y + (gaussianRandomNumY[iterator] * noise)\\n particle.position.z = initialpose.pose.pose.position.z\\n particle.orientation = rotateQuaternion(initialpose.pose.pose.orientation, randomYawArray[iterator])\\n\\n self.particlecloud.poses.append(particle)\\n iterator += 1\\n\\n return self.particlecloud\",\n \"def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\\n for sampling_result, img_meta in zip(sampling_results, img_metas):\\n bboxes = sampling_result.pos_bboxes\\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\\n -amplitude, amplitude)\\n # before jittering\\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\\n # after jittering\\n new_cxcy = cxcy + wh * random_offsets[:, :2]\\n new_wh = wh * (1 + random_offsets[:, 2:])\\n # xywh to xyxy\\n new_x1y1 = (new_cxcy - new_wh / 2)\\n new_x2y2 = (new_cxcy + new_wh / 2)\\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\\n # clip bboxes\\n max_shape = img_meta['img_shape']\\n if max_shape is not None:\\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\\n\\n sampling_result.pos_bboxes = new_bboxes\\n return sampling_results\",\n \"def uniform_random(self) -> None:\\n\\n size = self.circ_size\\n random.seed(self.seed)\\n\\n gates = [self.h, self.x, self.y, self.z, self.s, self.t, self.cx]\\n candidates = set(range(size))\\n\\n for i in range(size):\\n for j in range(size):\\n to_apply = random.choice(gates)\\n\\n num_qubits = 2 if to_apply == self.cx else 1\\n targets = random.sample(candidates, num_qubits)\\n to_apply(*targets)\\n\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def mutate_point_circ(mutated_genome):\\n seed = random.randint(0,3)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_circ(mutated_genome,index)\\n elif seed == 1:\\n shift_point_circ(mutated_genome,index)\\n elif seed == 2:\\n move_radius_circ(mutated_genome,index)\\n else: #seed == 3:\\n shift_radius_circ(mutated_genome,index)\",\n \"def getRandomCentroids(data_points, k):\\n return random.sample(data_points, k)\",\n \"def generate_random_surface_points() -> List[SurfacePoint]:\\n surface_points: List[SurfacePoint] = []\\n for _ in range(42):\\n surface_point = SurfacePoint(\\n idx=uuid.uuid4().hex,\\n x=_gen_random_number(),\\n y=_gen_random_number(),\\n z=_gen_random_number(),\\n x_uc_dist=DistUcEnum.uniform,\\n x_uc=_gen_random_number(),\\n y_uc_dist=DistUcEnum.uniform,\\n y_uc=_gen_random_number(),\\n z_uc_dist=DistUcEnum.uniform,\\n z_uc=_gen_random_number(),\\n smooth=0.01,\\n formation=\\\"Formation_0\\\",\\n )\\n surface_points.append(surface_point)\\n return surface_points\",\n \"def generate_base_points(num_points, domain_size, density_map=None,\\n reflect=True):\\n\\n def _try_points(num_points, prob):\\n prob = np.atleast_3d(prob)\\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\\n base_pts = []\\n N = 0\\n while N < num_points:\\n pt = np.random.rand(3) # Generate a point\\n # Test whether to keep it or not\\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\\n if np.random.rand(1) <= prob[indx][indy][indz]:\\n base_pts.append(pt)\\n N += 1\\n base_pts = np.array(base_pts)\\n return base_pts\\n\\n if len(domain_size) == 1: # Spherical\\n domain_size = np.array(domain_size)\\n r = domain_size[0]\\n if density_map is None:\\n # Make an image of a sphere filled with ones and use _try_points\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, 20] = 0\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to spherical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\\n # Reflect base points across perimeter\\n if reflect:\\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_spherical(r, theta, phi)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 2: # Cylindrical or Disk\\n domain_size = np.array(domain_size)\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, :] = 0\\n if domain_size[1] == 0: # Disk\\n density_map = density_map[:, :, 0]\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to cylindrical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n z = Z*domain_size[1]\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n inds = ~((z > domain_size[1]) + (z < 0))\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n if reflect:\\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_cylindrical(r, theta, z)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 3: # Cube or square\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n if domain_size[2] == 0:\\n density_map = density_map[:, :, 0]\\n base_pts = _try_points(num_points, density_map)\\n base_pts = base_pts*domain_size\\n if reflect:\\n base_pts = reflect_base_points(base_pts, domain_size)\\n\\n return base_pts\",\n \"def realize(self):\\n if numpy.random.rand() > self._P:\\n self._w *= 0.0\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def point_sample(img_meta,\\n img_features,\\n points,\\n proj_mat,\\n coord_type,\\n img_scale_factor,\\n img_crop_offset,\\n img_flip,\\n img_pad_shape,\\n img_shape,\\n aligned=True,\\n padding_mode='zeros',\\n align_corners=True):\\n\\n # apply transformation based on info in img_meta\\n points = apply_3d_transformation(\\n points, coord_type, img_meta, reverse=True)\\n\\n # project points to camera coordinate\\n pts_2d = points_cam2img(points, proj_mat)\\n\\n # img transformation: scale -> crop -> flip\\n # the image is resized by img_scale_factor\\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\\n img_coors -= img_crop_offset\\n\\n # grid sample, the valid grid range should be in [-1,1]\\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\\n\\n if img_flip:\\n # by default we take it as horizontal flip\\n # use img_shape before padding for flip\\n orig_h, orig_w = img_shape\\n coor_x = orig_w - coor_x\\n\\n h, w = img_pad_shape\\n coor_y = coor_y / h * 2 - 1\\n coor_x = coor_x / w * 2 - 1\\n grid = torch.cat([coor_x, coor_y],\\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\\n\\n # align_corner=True provides higher performance\\n mode = 'bilinear' if aligned else 'nearest'\\n point_features = F.grid_sample(\\n img_features,\\n grid,\\n mode=mode,\\n padding_mode=padding_mode,\\n align_corners=align_corners) # 1xCx1xN feats\\n\\n return point_features.squeeze().t()\",\n \"def generate_random_point(det):\\n xmin, ymin, zmin = det.ActiveVolume().Min()\\n xmax, ymax, zmax = det.ActiveVolume().Max()\\n return geoalgo.Vector(np.random.random() * (xmax - xmin) + xmin,\\n np.random.random() * (ymax - ymin) + ymin,\\n np.random.random() * (zmax - zmin) + zmin)\",\n \"def _generate_pores(self):\\n logger.info(\\\"Place randomly located pores in the domain\\\")\\n #Original Random Point Generator\\n #coords = sp.rand(self._Np,3)*[self._Lx,self._Ly,self._Lz]\\n #Seeding Code\\n coords = np.zeros([self._Np,3])\\n #reject points close to boundaries - if False there will be slightly more\\n rejection = [False,False,True]\\n for j in range(3):\\n i = 0\\n while i < self._Np:\\n coord = np.random.uniform(0,1,1)\\n if self._reject(coord) == rejection[j]:\\n coords[i][j]=coord\\n i += 1\\n coords*=np.array([self._Lx,self._Ly,self._Lz])\\n #Seeding Code\\n #Uniform Random Generator\\n #coords = np.array([np.random.uniform(0,self._Lx,self._Np),np.random.uniform(0,self._Ly,self._Np),np.random.uniform(0,self._Lz,self._Np)]).T\\n\\n self['pore.coords'] = coords\\n logger.debug(\\\"End of method\\\")\",\n \"def mutate_point_trig(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_trig(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_trig(mutated_genome,index)\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def pepper(self, prob=0.08):\\n h, w, c = self.img.shape\\n for i in range(h):\\n for j in range(w):\\n if random() < prob:\\n self.img[i, j] = 0\\n\\n self.edits.append(f\\\"pepper:{prob}\\\")\\n return self\",\n \"def prep_pointcloud(input_dict,\\n root_path,\\n voxel_generator,\\n target_assigner,\\n db_sampler=None,\\n max_voxels=20000,\\n max_sweeps=10,\\n remove_outside_points=False,\\n training=True,\\n create_targets=True,\\n shuffle_points=False,\\n remove_unknown=False,\\n gt_rotation_noise=(-np.pi / 3, np.pi / 3),\\n gt_loc_noise_std=(1.0, 1.0, 1.0),\\n global_rotation_noise=(-np.pi / 4, np.pi / 4),\\n global_scaling_noise=(0.95, 1.05),\\n global_random_rot_range=(0.78, 2.35),\\n global_translate_noise_std=(0, 0, 0),\\n num_point_features=4,\\n anchor_area_threshold=1,\\n gt_points_drop=0.0,\\n gt_drop_max_keep=10,\\n remove_points_after_sample=True,\\n anchor_cache=None,\\n remove_environment=False,\\n random_crop=False,\\n reference_detections=None,\\n out_size_factor=2,\\n use_group_id=False,\\n multi_gpu=False,\\n min_points_in_gt=-1,\\n random_flip_x=True,\\n random_flip_y=True,\\n sample_importance=1.0,\\n out_dtype=np.float32):\\n t = time.time()\\n class_names = target_assigner.classes\\n points = input_dict[\\\"lidar\\\"][\\\"points\\\"]\\n indices = input_dict[\\\"lidar\\\"][\\\"indices\\\"]\\n origins = input_dict[\\\"lidar\\\"][\\\"origins\\\"]\\n if training:\\n anno_dict = input_dict[\\\"lidar\\\"][\\\"annotations\\\"]\\n gt_dict = {\\n \\\"gt_boxes\\\": anno_dict[\\\"boxes\\\"],\\n \\\"gt_names\\\": anno_dict[\\\"names\\\"],\\n \\\"gt_importance\\\": np.ones([anno_dict[\\\"boxes\\\"].shape[0]], dtype=anno_dict[\\\"boxes\\\"].dtype),\\n }\\n if \\\"difficulty\\\" not in anno_dict:\\n difficulty = np.zeros([anno_dict[\\\"boxes\\\"].shape[0]],\\n dtype=np.int32)\\n gt_dict[\\\"difficulty\\\"] = difficulty\\n else:\\n gt_dict[\\\"difficulty\\\"] = anno_dict[\\\"difficulty\\\"]\\n if use_group_id and \\\"group_ids\\\" in anno_dict:\\n group_ids = anno_dict[\\\"group_ids\\\"]\\n gt_dict[\\\"group_ids\\\"] = group_ids\\n calib = None\\n if \\\"calib\\\" in input_dict:\\n calib = input_dict[\\\"calib\\\"]\\n\\n # # Disable these two since we do not do this for NuScenes\\n # if reference_detections is not None:\\n # assert calib is not None and \\\"image\\\" in input_dict\\n # C, R, T = box_np_ops.projection_matrix_to_CRT_kitti(P2)\\n # frustums = box_np_ops.get_frustum_v2(reference_detections, C)\\n # frustums -= T\\n # frustums = np.einsum('ij, akj->aki', np.linalg.inv(R), frustums)\\n # frustums = box_np_ops.camera_to_lidar(frustums, rect, Trv2c)\\n # surfaces = box_np_ops.corner_to_surfaces_3d_jit(frustums)\\n # masks = points_in_convex_polygon_3d_jit(points, surfaces)\\n # points = points[masks.any(-1)]\\n # if remove_outside_points:\\n # assert calib is not None\\n # image_shape = input_dict[\\\"image\\\"][\\\"image_shape\\\"]\\n # points = box_np_ops.remove_outside_points(\\n # points, calib[\\\"rect\\\"], calib[\\\"Trv2c\\\"], calib[\\\"P2\\\"], image_shape)\\n\\n # # Very interesting attempt\\n # # I have tried the same and found it doesn't really work\\n # if remove_environment is True and training:\\n # selected = kitti.keep_arrays_by_name(gt_names, target_assigner.classes)\\n # _dict_select(gt_dict, selected)\\n # masks = box_np_ops.points_in_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n # points = points[masks.any(-1)]\\n\\n metrics = {}\\n\\n point_indices_to_remove = None\\n if training:\\n \\\"\\\"\\\"\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n bev_map = simplevis.nuscene_vis(points, boxes_lidar)\\n cv2.imshow('pre-noise', bev_map)\\n \\\"\\\"\\\"\\n selected = kitti.drop_arrays_by_name(gt_dict[\\\"gt_names\\\"], [\\\"Denture\\\"])\\n _dict_select(gt_dict, selected)\\n if remove_unknown:\\n remove_mask = gt_dict[\\\"difficulty\\\"] == -1\\n \\\"\\\"\\\"\\n gt_boxes_remove = gt_boxes[remove_mask]\\n gt_boxes_remove[:, 3:6] += 0.25\\n points = prep.remove_points_in_boxes(points, gt_boxes_remove)\\n \\\"\\\"\\\"\\n keep_mask = np.logical_not(remove_mask)\\n _dict_select(gt_dict, keep_mask)\\n gt_dict.pop(\\\"difficulty\\\")\\n\\n # This part is interesting - we will need to do the same\\n if min_points_in_gt > 0:\\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n mask = point_counts >= min_points_in_gt\\n _dict_select(gt_dict, mask)\\n\\n gt_boxes_mask = np.array(\\n [n in class_names for n in gt_dict[\\\"gt_names\\\"]], dtype=np.bool_)\\n\\n if db_sampler is not None:\\n group_ids = None\\n if \\\"group_ids\\\" in gt_dict:\\n group_ids = gt_dict[\\\"group_ids\\\"]\\n\\n sampled_dict = db_sampler.sample_all(\\n root_path,\\n gt_dict[\\\"gt_boxes\\\"],\\n gt_dict[\\\"gt_names\\\"],\\n num_point_features,\\n random_crop,\\n gt_group_ids=group_ids,\\n calib=calib)\\n\\n if sampled_dict is not None:\\n sampled_gt_names = sampled_dict[\\\"gt_names\\\"]\\n sampled_gt_boxes = sampled_dict[\\\"gt_boxes\\\"]\\n sampled_points = sampled_dict[\\\"points\\\"]\\n sampled_gt_masks = sampled_dict[\\\"gt_masks\\\"]\\n gt_dict[\\\"gt_names\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_names\\\"], sampled_gt_names], axis=0)\\n gt_dict[\\\"gt_boxes\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_boxes\\\"], sampled_gt_boxes])\\n gt_boxes_mask = np.concatenate(\\n [gt_boxes_mask, sampled_gt_masks], axis=0)\\n sampled_gt_importance = np.full(\\n [sampled_gt_boxes.shape[0]], sample_importance,\\n dtype=sampled_gt_boxes.dtype)\\n gt_dict[\\\"gt_importance\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_importance\\\"], sampled_gt_importance])\\n\\n if group_ids is not None:\\n sampled_group_ids = sampled_dict[\\\"group_ids\\\"]\\n gt_dict[\\\"group_ids\\\"] = np.concatenate(\\n [gt_dict[\\\"group_ids\\\"], sampled_group_ids])\\n\\n # # Commented out because we have a new way of removing points\\n # if remove_points_after_sample:\\n # masks = box_np_ops.points_in_rbbox(points, sampled_gt_boxes)\\n # point_indices_to_remove = np.flatnonzero(masks.any(-1))\\n # # # Delay this process so we can use the full point cloud\\n # # # when we do the ray stopping algorithm\\n # # points = points[np.logical_not(masks.any(-1))]\\n\\n # # Paste objects behind so that we don't have to update indices\\n # points = np.concatenate([sampled_points, points], axis=0)\\n points = np.concatenate([points, sampled_points], axis=0)\\n\\n pc_range = voxel_generator.point_cloud_range\\n group_ids = None\\n if \\\"group_ids\\\" in gt_dict:\\n group_ids = gt_dict[\\\"group_ids\\\"]\\n\\n # # Disable this one for now (not used in PointPillars anyways)\\n # prep.noise_per_object_v3_(\\n # gt_dict[\\\"gt_boxes\\\"],\\n # points,\\n # gt_boxes_mask,\\n # rotation_perturb=gt_rotation_noise,\\n # center_noise_std=gt_loc_noise_std,\\n # global_random_rot_range=global_random_rot_range,\\n # group_ids=group_ids,\\n # num_try=100)\\n\\n # should remove unrelated objects after noise per object\\n # for k, v in gt_dict.items():\\n # print(k, v.shape)\\n _dict_select(gt_dict, gt_boxes_mask)\\n gt_classes = np.array(\\n [class_names.index(n) + 1 for n in gt_dict[\\\"gt_names\\\"]],\\n dtype=np.int32)\\n gt_dict[\\\"gt_classes\\\"] = gt_classes\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.random_flip(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, 0.5, random_flip_x, random_flip_y)\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.global_rotation_v2(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, *global_rotation_noise)\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.global_scaling_v2(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, *global_scaling_noise)\\n prep.global_translate_(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, global_translate_noise_std)\\n bv_range = voxel_generator.point_cloud_range[[0, 1, 3, 4]]\\n mask = prep.filter_gt_box_outside_range_by_center(gt_dict[\\\"gt_boxes\\\"], bv_range)\\n _dict_select(gt_dict, mask)\\n\\n # limit rad to [-pi, pi]\\n gt_dict[\\\"gt_boxes\\\"][:, 6] = box_np_ops.limit_period(\\n gt_dict[\\\"gt_boxes\\\"][:, 6], offset=0.5, period=2 * np.pi)\\n\\n # boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n # bev_map = simplevis.nuscene_vis(points, boxes_lidar)\\n # cv2.imshow('post-noise', bev_map)\\n # cv2.waitKey(0)\\n\\n # # Disable this for now (not used in PointPillars anyways)\\n # if shuffle_points:\\n # # shuffle is a little slow.\\n # np.random.shuffle(points)\\n\\n # [0, -40, -3, 70.4, 40, 1]\\n voxel_size = voxel_generator.voxel_size\\n pc_range = voxel_generator.point_cloud_range\\n grid_size = voxel_generator.grid_size\\n\\n # organize points into lists based on timestamps\\n time_stamps = points[indices[:-1], -1] # counting on the fact we do not miss points from any intermediate time_stamps\\n time_stamps = (time_stamps[:-1]+time_stamps[1:])/2\\n time_stamps = [-1000.0] + time_stamps.tolist() + [1000.0] # add boundaries\\n time_stamps = np.array(time_stamps)\\n\\n # # LL_OCCUPIED, LL_FREE = 0.85, -0.4\\n # lo_occupied = np.log(0.7 / (1 - 0.7))\\n # lo_free = np.log(0.4 / (1 - 0.4))\\n\\n # is there are additional points (from database sampling)\\n num_original = indices[-1]\\n if len(points) > num_original:\\n # split data into two half (indexed and un-indexed)\\n original_points, sampled_points = points[:num_original], points[num_original:]\\n # compute occupancy and masks\\n # visibility, original_mask, sampled_mask = mapping.compute_visibility_and_masks(\\n # original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size)\\n # )\\n logodds, original_mask, sampled_mask = mapping.compute_logodds_and_masks(\\n original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size) # , lo_occupied, lo_free\\n )\\n # apply visible mask\\n points = np.concatenate((original_points[original_mask], sampled_points[sampled_mask]))\\n else:\\n # visibility = mapping.compute_visibility(\\n # points, origins, time_stamps, pc_range, min(voxel_size)\\n # )\\n logodds = mapping.compute_logodds(\\n points, origins, time_stamps, pc_range, min(voxel_size) #, lo_occupied, lo_free\\n )\\n\\n # T = len(time_stamps)-1\\n # visibility = visibility.reshape(T, -1)\\n # if T < (1 + max_sweeps):\\n # visibility = np.pad(visibility, ((0, (1+max_sweeps)-T), (0,0)), 'edge')\\n\\n # with open(f'./utils/mapping/examples/{time.time()}.pkl', 'wb') as f:\\n # ##\\n # pickle.dump(original_points, f)\\n # pickle.dump(sampled_points, f)\\n # pickle.dump(origins, f)\\n # pickle.dump(time_stamps, f)\\n # pickle.dump(pc_range, f)\\n # pickle.dump(voxel_size, f)\\n # ##\\n # pickle.dump(occupancy, f)\\n # pickle.dump(original_mask, f)\\n # pickle.dump(sampled_mask, f)\\n\\n if training:\\n if min_points_in_gt > 0:\\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n mask = point_counts >= min_points_in_gt\\n _dict_select(gt_dict, mask)\\n\\n # [352, 400]\\n t1 = time.time()\\n if not multi_gpu:\\n res = voxel_generator.generate(\\n points, max_voxels)\\n voxels = res[\\\"voxels\\\"]\\n coordinates = res[\\\"coordinates\\\"]\\n num_points = res[\\\"num_points_per_voxel\\\"]\\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\\n else:\\n res = voxel_generator.generate_multi_gpu(\\n points, max_voxels)\\n voxels = res[\\\"voxels\\\"]\\n coordinates = res[\\\"coordinates\\\"]\\n num_points = res[\\\"num_points_per_voxel\\\"]\\n num_voxels = np.array([res[\\\"voxel_num\\\"]], dtype=np.int64)\\n metrics[\\\"voxel_gene_time\\\"] = time.time() - t1\\n example = {\\n 'voxels': voxels,\\n # 'visibility': visibility,\\n 'logodds': logodds, \\n 'num_points': num_points,\\n 'coordinates': coordinates,\\n \\\"num_voxels\\\": num_voxels,\\n \\\"metrics\\\": metrics,\\n }\\n if calib is not None:\\n example[\\\"calib\\\"] = calib\\n feature_map_size = grid_size[:2] // out_size_factor\\n feature_map_size = [*feature_map_size, 1][::-1]\\n # print(f'feature_map_size in prep_pointcloud(): {feature_map_size}')\\n if anchor_cache is not None:\\n # print('having anchor cache')\\n anchors = anchor_cache[\\\"anchors\\\"]\\n anchors_bv = anchor_cache[\\\"anchors_bv\\\"]\\n anchors_dict = anchor_cache[\\\"anchors_dict\\\"]\\n matched_thresholds = anchor_cache[\\\"matched_thresholds\\\"]\\n unmatched_thresholds = anchor_cache[\\\"unmatched_thresholds\\\"]\\n\\n else:\\n # print('NOT having anchor cache')\\n ret = target_assigner.generate_anchors(feature_map_size)\\n anchors = ret[\\\"anchors\\\"]\\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\\n anchors_bv = box_np_ops.rbbox2d_to_near_bbox(\\n anchors[:, [0, 1, 3, 4, 6]])\\n matched_thresholds = ret[\\\"matched_thresholds\\\"]\\n unmatched_thresholds = ret[\\\"unmatched_thresholds\\\"]\\n # print(f'anchors.shape: {anchors.shape}')\\n\\n example[\\\"anchors\\\"] = anchors\\n anchors_mask = None\\n if anchor_area_threshold >= 0:\\n # slow with high resolution. recommend disable this forever.\\n coors = coordinates\\n dense_voxel_map = box_np_ops.sparse_sum_for_anchors_mask(\\n coors, tuple(grid_size[::-1][1:]))\\n dense_voxel_map = dense_voxel_map.cumsum(0)\\n dense_voxel_map = dense_voxel_map.cumsum(1)\\n anchors_area = box_np_ops.fused_get_anchors_area(\\n dense_voxel_map, anchors_bv, voxel_size, pc_range, grid_size)\\n anchors_mask = anchors_area > anchor_area_threshold\\n # example['anchors_mask'] = anchors_mask.astype(np.uint8)\\n example['anchors_mask'] = anchors_mask\\n # print(\\\"prep time\\\", time.time() - t)\\n metrics[\\\"prep_time\\\"] = time.time() - t\\n if not training:\\n return example\\n example[\\\"gt_names\\\"] = gt_dict[\\\"gt_names\\\"]\\n # voxel_labels = box_np_ops.assign_label_to_voxel(gt_boxes, coordinates,\\n # voxel_size, coors_range)\\n if create_targets:\\n t1 = time.time()\\n targets_dict = target_assigner.assign(\\n anchors,\\n anchors_dict,\\n gt_dict[\\\"gt_boxes\\\"],\\n anchors_mask,\\n gt_classes=gt_dict[\\\"gt_classes\\\"],\\n gt_names=gt_dict[\\\"gt_names\\\"],\\n matched_thresholds=matched_thresholds,\\n unmatched_thresholds=unmatched_thresholds,\\n importance=gt_dict[\\\"gt_importance\\\"])\\n\\n \\\"\\\"\\\"\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n bev_map = simplevis.nuscene_vis(points, boxes_lidar, gt_dict[\\\"gt_names\\\"])\\n assigned_anchors = anchors[targets_dict['labels'] > 0]\\n ignored_anchors = anchors[targets_dict['labels'] == -1]\\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], ignored_anchors, [128, 128, 128], 2)\\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], assigned_anchors, [255, 0, 0])\\n cv2.imshow('anchors', bev_map)\\n cv2.waitKey(0)\\n\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n pp_map = np.zeros(grid_size[:2], dtype=np.float32)\\n voxels_max = np.max(voxels[:, :, 2], axis=1, keepdims=False)\\n voxels_min = np.min(voxels[:, :, 2], axis=1, keepdims=False)\\n voxels_height = voxels_max - voxels_min\\n voxels_height = np.minimum(voxels_height, 4)\\n # sns.distplot(voxels_height)\\n # plt.show()\\n pp_map[coordinates[:, 1], coordinates[:, 2]] = voxels_height / 4\\n pp_map = (pp_map * 255).astype(np.uint8)\\n pp_map = cv2.cvtColor(pp_map, cv2.COLOR_GRAY2RGB)\\n pp_map = simplevis.draw_box_in_bev(pp_map, [-50, -50, 3, 50, 50, 1], boxes_lidar, [128, 0, 128], 1)\\n cv2.imshow('heights', pp_map)\\n cv2.waitKey(0)\\n \\\"\\\"\\\"\\n example.update({\\n 'labels': targets_dict['labels'],\\n 'reg_targets': targets_dict['bbox_targets'],\\n # 'reg_weights': targets_dict['bbox_outside_weights'],\\n 'importance': targets_dict['importance'],\\n })\\n return example\",\n \"def randomize(self):\\n\\t\\tif self.hasRandomizedAmplitudes:\\n\\t\\t\\tself.unrandomize()\\n\\t\\tself.randoms = np.random.multivariate_normal(np.zeros((2*self.totalBins)), self.coma)\\n\\t\\tfor i in range(self.totalBins):\\n\\t\\t\\tself.reals[i] += self.randoms[2*i ]\\n\\t\\t\\tself.imags[i] += self.randoms[2*i+1]\\n\\t\\tself.hasRandomizedAmplitudes = True\",\n \"def reset(self):\\n self.x = random.uniform(-0.05, 0.05)\\n self.x_dot = random.uniform(-0.05, 0.05)\\n self.theta = random.uniform(-0.05, 0.05)\\n self.theta_dot = random.uniform(-0.05, 0.05)\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def elapseTime(self, gameState):\\n newParticleList = []\\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\\n # likely the ghost is to move to that position\\n for particle in self.particles:\\n newPosDist = self.getPositionDistribution(gameState, particle)\\n newParticleList.append(util.sample(newPosDist))\\n self.particles = newParticleList\",\n \"def mutate_point_poly(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 3: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def JitterPoints(points, sigma=0.01): \\n C = 3\\n assert(points.shape[1] == C)\\n\\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\\n return points + randJitters\",\n \"def MovePoint(pos,points,s=0.5, k = 1000): \\n \\n x = [pos[0]] \\n y = [pos[1]]\\n rdm.seed(1) # comment out if you want randomness\\n for i in range(k):\\n n = len(points)\\n r = int(rdm.random()*n)\\n \\n x.append(x[i] + (points[r][0] - x[i]) * s)\\n y.append(y[i] + (points[r][1] - y[i]) * s)\\n\\n \\n return(x,y)\",\n \"def test_rotating_phantom(self):\\n cheese = TomoCheese.from_demo_images()\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\\n for img in cheese.dicom_stack:\\n img.array = rotate(img.array, angle=3, mode=\\\"edge\\\")\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def random_translation(canvas, img):\",\n \"def _sample_z(self, a):\\n r = np.random.rand()\\n return ((1 + r * (a - 1))**2) / a\",\n \"def _get_random_transform(self, img_shape, seed=None):\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if self.rotation_range:\\n theta = np.random.uniform(\\n -self.rotation_range,\\n self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n try: # 1-D array-like or int\\n tx = np.random.choice(self.height_shift_range)\\n tx *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n tx = np.random.uniform(-self.height_shift_range,\\n self.height_shift_range)\\n if np.max(self.height_shift_range) < 1:\\n tx *= img_shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n try: # 1-D array-like or int\\n ty = np.random.choice(self.width_shift_range)\\n ty *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n ty = np.random.uniform(-self.width_shift_range,\\n self.width_shift_range)\\n if np.max(self.width_shift_range) < 1:\\n ty *= img_shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(\\n -self.shear_range,\\n self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(\\n self.zoom_range[0],\\n self.zoom_range[1],\\n 2)\\n\\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\\n\\n channel_shift_intensity = None\\n if self.channel_shift_range != 0:\\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\\n self.channel_shift_range)\\n\\n brightness = None\\n if self.brightness_range is not None:\\n brightness = np.random.uniform(self.brightness_range[0],\\n self.brightness_range[1])\\n\\n transform_parameters = {'theta': theta,\\n 'tx': tx,\\n 'ty': ty,\\n 'shear': shear,\\n 'zx': zx,\\n 'zy': zy,\\n 'flip_horizontal': flip_horizontal,\\n 'flip_vertical': flip_vertical,\\n 'channel_shift_intensity': channel_shift_intensity,\\n 'brightness': brightness}\\n\\n return transform_parameters\",\n \"def mutate_point_rect(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_rect(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_rect(mutated_genome,index)\",\n \"def randomize(self):\\n #first take care of all parameters (from N(0,1))\\n x = self._get_params_transformed()\\n x = np.random.randn(x.size)\\n self._set_params_transformed(x)\\n #now draw from prior where possible\\n x = self._get_params()\\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\\n self._set_params(x)\\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)\",\n \"def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\\n def genPos():\\n r = radius_scale * self.np_random.rand() + radius_offset\\n a = -np.pi * angle_scale + angle_offset\\n b = np.pi * angle_scale + angle_offset\\n ang = (b - a) * self.np_random.rand() + a\\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\\n def isNear(pos, poss):\\n for p, o in poss:\\n if np.linalg.norm(p - pos) < near_distance:\\n return True\\n return False\\n def genPosRetry(poss):\\n for i in range(retry):\\n pos = genPos()\\n if not isNear(pos, poss):\\n return pos\\n return genPos()\\n poss = []\\n for i in range(num):\\n pos = genPosRetry(poss)\\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\\n poss.append((pos, orn))\\n self.np_random.shuffle(poss)\\n return poss\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def random_plane_points(num_points, bounds):\\n\\n # Infer dimension of data from bounds\\n (bounds, dimension) = infer_dimension(bounds)\\n\\n # Generate points and rescale to fit bounds\\n points = np.random.rand(num_points, dimension)\\n unit_mean = [0.5] * dimension\\n shifted_points = points - unit_mean + bounds.mean(axis=1)\\n scale = bounds[:, 1] - bounds[:, 0]\\n rescaled_points = np.dot(shifted_points, np.diag(scale))\\n\\n return rescaled_points\",\n \"def randTheta(k, scale=1):\\n return generatePoints(1, k, scale=scale)[0].reshape((k + 1, -1))\",\n \"def totem_random():\\n random_head()\\n random_head()\\n random_head()\",\n \"def random_transform(self, x):\\n pass\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def cointoss():\\n return random.random() < 0.5\",\n \"def repick(g1_x, g1_y, g1_z):\\n i = random.randint(0, len(g1_x) - 1)\\n x = g1_x[i]\\n y = g1_y[i]\\n z = g1_z[i]\\n return x, y, z\",\n \"def randomizePlayerPose(transform, arena_radius=8):\\n initial_r = arena_radius * random.random()\\n initial_theta = 2 * math.pi * random.random()\\n initial_x = initial_r * math.cos(initial_theta)\\n initial_y = initial_r * math.sin(initial_theta)\\n initial_rotation = 2 * math.pi * random.random()\\n transform.translation.x = initial_x\\n transform.translation.y = initial_y\\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])\",\n \"def resample(self):\\n self.X = np.random.uniform(-1, 1, (100, 2))\\n self.generate_y()\\n self.phi = None\\n self.K = 0\\n self.centers = None\\n self.cluster_sizes = None\\n self.g = None\\n self.gamma = None\",\n \"def __call__(self, results):\\n if np.random.rand() > self.prob:\\n return results\\n h, w = results['image'].shape[:2]\\n center = self.center\\n if center is None:\\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\\n angle = random_negative(self.angle, self.random_negative_prob)\\n self._rotate_img(results, angle, center, self.scale)\\n return results\",\n \"def move(self):\\n if self._z >= 75:\\n a = random.random()\\n print(str(a))\\n if a < 0.2:\\n self._z += 1\\n if a > 0.2 and a < 0.9:\\n self._z -= 1\\n if a > 0.9:\\n self._z = self._z\\n else: \\n self._z -= 1\\n \\n b = random.random()\\n print(str(b))\\n if b < 0.1:\\n self._y += 1\\n if b > 0.1 and b < 0.2:\\n self._y -= 1\\n if b > 0.2 and b < 0.25:\\n self._x -= 1\\n if b > 0.25:\\n self._x += 1\",\n \"def random_sample(grid_size):\\r\\n g = grid_size\\r\\n x_range = g[1] - g[0]\\r\\n\\r\\n y_range = g[3] - g[2]\\r\\n\\r\\n x_off = g[0]\\r\\n y_off = g[2]\\r\\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \\r\\n return (x,y)\",\n \"def generate_random_DC_crack_coupled_tensor():\\n # 1. Generate random DC MT and crack MT:\\n # generate DC MT:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\\n # Get between small range:\\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\\n random_num = random.random()\\n if random_num <= 0.5:\\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\\n elif random_num > 0.5:\\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n # And redistribute evenly everywhere on boundary:\\n random_num = random.random()\\n if random_num>0.25 and random_num<=0.5:\\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\\n if random_num>0.5 and random_num<=0.75:\\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\\n if random_num>0.75 and random_num<=1.0:\\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\\n # --- ---\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # theta_lune_sphere = random.random()*np.pi/2.\\n # elif random_num > 0.5:\\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # phi_lune_sphere = np.pi/6.\\n # elif random_num > 0.5:\\n # phi_lune_sphere = -1.*np.pi/6.\\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\\n # 2. Combine DC and crack tensors:\\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\\n # 3. Randomly rotate DC-crack MT to random orientation:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\\n # 4. Normalise and get 6 MT:\\n # Get 6 MT:\\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\\n # And normallise so that moment tensor magnitude = 1:\\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\\n return DC_crack_six_MT_rotated_normalised, random_amp_frac\",\n \"def shift_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def get_random_translations(atom_pos, beam_focus_size, jet_radius):\\n N = len(atom_pos)\\n beam_focus_radius = beam_focus_size/2\\n flag = True\\n while(flag):\\n x_trans = beam_focus_radius*np.random.uniform(-1, 1)\\n y_trans = beam_focus_radius*np.random.uniform(-1, 1)\\n z_trans = jet_radius*np.random.uniform(-1, 1)\\n trans = [[x_trans, y_trans, z_trans]]*N\\n trans = np.asarray(trans)\\n new_pos = atom_pos + trans\\n print (\\\"trans_new_pos\\\", new_pos)\\n for i in range(N):\\n if (np.sqrt(new_pos[i][0]**2 + new_pos[i][1]**2) >= beam_focus_radius):\\n flag = False\\n break\\n else:\\n flag = False\\n return new_pos\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def aecSpaceRandomTowers():\\n origin = aecPoint(0, 0, 0)\\n displace = 175\\n spacer = aecSpacer()\\n shaper = aecShaper()\\n \\n def full(point, xWidth, yDepth, zHeight, level):\\n floor = aecSpace()\\n floor.boundary = shaper.makeBox(point, xWidth, yDepth)\\n floor.height = zHeight\\n floor.level = level\\n setColors([floor])\\n return [floor]\\n \\n def halfDepth(point, xWidth, yDepth, zHeight, level):\\n depth = yDepth * 0.5\\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, xWidth, depth)\\n half1.height = zHeight\\n half1.level = level\\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def halfWidth(point, xWidth, yDepth, zHeight, level):\\n width = xWidth * 0.5\\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, width, yDepth)\\n half1.height = zHeight\\n half1.level = level\\n halfSpaces = [half1] + spacer.row(half1)\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def quarterDepth(point, xWidth, yDepth, zHeight, level):\\n if randint(0, 1) == 0:\\n depth = yDepth * 0.25\\n scale = 3\\n else:\\n depth = yDepth * 0.75\\n scale = 0.333333333 \\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, xWidth, depth)\\n half1.height = zHeight\\n half1.level = level \\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\\n halfSpaces[1].scale(1, scale, 1, halfSpaces[1].points_floor[0])\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def quarterWidth(point, xWidth, yDepth, zHeight, level):\\n if randint(0, 1) == 0:\\n width = xWidth * 0.25\\n scale = 3\\n else:\\n width = xWidth * 0.75\\n scale = 0.333333333 \\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, width, yDepth)\\n half1.height = zHeight\\n half1.level = level \\n halfSpaces = [half1] + spacer.row(half1)\\n halfSpaces[1].scale(scale, 1, 1, halfSpaces[1].points_floor[0])\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def setColors(halfSpaces):\\n colors = [aecColor.blue, aecColor.orange, aecColor.purple, aecColor.yellow]\\n colorPick = randint(0, 3)\\n halfSpaces[0].color = colors[colorPick]\\n if len(halfSpaces) == 1: return\\n colors.reverse()\\n halfSpaces[1].color = colors[colorPick]\\n \\n def makeFloor(point, xWidth, yDepth, zHeight, level):\\n floorType = randint(0, 4)\\n if floorType == 0: floorSpaces = full(point, xWidth, yDepth, zHeight, level)\\n if floorType == 1: floorSpaces = halfDepth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 2: floorSpaces = halfWidth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 3: floorSpaces = quarterDepth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 4: floorSpaces = quarterWidth(point, xWidth, yDepth, zHeight, level)\\n return floorSpaces\\n \\n def makeCore(point, xWidth, yDepth, zHeight): \\n xCoord = (point.x - 5) + (xWidth * 0.5)\\n yCoord = (point.y + (yDepth * (randint(0, 9) * 0.1)))\\n point = aecPoint(xCoord, yCoord, point.z)\\n core = aecSpace()\\n core.boundary = shaper.makeBox(point, 10, 20)\\n core.height = zHeight\\n core.color = aecColor.gray\\n return [core]\\n \\n def makeTower(point):\\n floors = []\\n xWidth = uniform(20, 60)\\n yDepth = uniform(20, 60)\\n levels = randint(5, 50)\\n zHeight = uniform(3, 6)\\n plinth = aecSpace()\\n plinth.boundary = shaper.makeBox(point, xWidth, yDepth)\\n plinthScaleX = (uniform(1, 2.5))\\n plinthScaleY = (uniform(1, 2.5))\\n plinth.scale(plinthScaleX, plinthScaleY, 2, plinth.centroid_floor)\\n plinth.height = (zHeight * 2)\\n plinth.color = aecColor.green\\n floors.append(plinth)\\n floors = floors + makeCore(point, xWidth, yDepth, zHeight * (levels + 3))\\n level = (zHeight * 2)\\n x = 0\\n while x < levels:\\n floors = floors + makeFloor(point, xWidth, yDepth, zHeight, level)\\n level += zHeight\\n x += 1 \\n return floors\\n \\n def makeTowerRow(point, columns, displacement):\\n towers = []\\n towers = towers + makeTower(point)\\n x = 0\\n while x < columns:\\n point.x += displacement\\n towers = towers + makeTower(point)\\n x += 1\\n return towers\\n \\n def makeTowerRows(point, displacement, columns, rows):\\n towers = []\\n x = 0\\n while x < rows:\\n towers = towers + makeTowerRow(point, columns, displacement)\\n point.x = 0\\n point.y += displacement\\n x += 1\\n return towers\\n \\n return makeTowerRows(origin, displace, 4, 5)\",\n \"def sample_preimage(self, point, seed=None):\\r\\n [[a, b], [c, d]] = self.B0_fft\\r\\n\\r\\n # We compute a vector t_fft such that:\\r\\n # (fft(point), fft(0)) * B0_fft = t_fft\\r\\n # Because fft(0) = 0 and the inverse of B has a very specific form,\\r\\n # we can do several optimizations.\\r\\n '''\\r\\n print(\\\"---------Inside sample_preimage----------\\\")\\r\\n print(\\\"point: \\\", point)\\r\\n '''\\r\\n\\r\\n point_fft = fft(point)\\r\\n\\r\\n t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]\\r\\n t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]\\r\\n t_fft = [t0_fft, t1_fft]\\r\\n\\r\\n # We now compute v such that:\\r\\n # v = z * B0 for an integral vector z\\r\\n # v is close to (point, 0)\\r\\n if seed is None:\\r\\n # If no seed is defined, use urandom as the pseudo-random source.\\r\\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)\\r\\n\\r\\n else:\\r\\n # If a seed is defined, initialize a ChaCha20 PRG\\r\\n # that is used to generate pseudo-randomness.\\r\\n chacha_prng = ChaCha20(seed)\\r\\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,\\r\\n chacha_prng.randombytes)\\r\\n\\r\\n v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))\\r\\n v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))\\r\\n v0 = [int(round(elt)) for elt in ifft(v0_fft)]\\r\\n v1 = [int(round(elt)) for elt in ifft(v1_fft)]\\r\\n\\r\\n # The difference s = (point, 0) - v is such that:\\r\\n # s is short\\r\\n # s[0] + s[1] * h = point\\r\\n s = [sub(point, v0), neg(v1)]\\r\\n return s\",\n \"def random():\\n np.random.seed(0)\",\n \"def modify_pt(pt=None,):\\n global dim\\n mod_rand_pt = []\\n\\n for i_ in range(dim):\\n for j_ in range(i_, dim):\\n mod_rand_pt.append(pt[i_] * pt[j_])\\n\\n mod_rand_pt.append(1.)\\n return mod_rand_pt\",\n \"def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]]) # rotate along y axis\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\\n return rotated_data\",\n \"def remove_point(mutated_genome,index):\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n del mutated_genome[index][2][point_index]\",\n \"def move_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\\n point = (Xval,Yval)\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n mutated_genome[index][2][point_index] = point\",\n \"def rand_raster(center, step_size, num_points, random):\\n xscan = []\\n yscan = []\\n \\n xcenter = center[0] # first element of center array\\n ycenter = center[1] # second element of center array\\n \\n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\\n \\n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n \\n # Creates two arrays xscan and yscan\\n for step, ystep in enumerate(yrange):\\n xscan.append(xrange[::(-1)**step])\\n yscan.append(np.ones_like(xrange) * ystep)\\n \\n xscan = np.concatenate(xscan)\\n yscan = np.concatenate(yscan)\\n \\n # Combine the two arrays into a list of vectors\\n raster = []\\n \\n for i in range(0, len(xscan)):\\n scan_element = []\\n \\n scan_element.append(xscan[i])\\n scan_element.append(yscan[i])\\n raster.append(scan_element)\\n \\n return raster\",\n \"def generate(random, lower, upper, count=1):\\n if count > 1:\\n points = []\\n\\n for x in range(lower.x, upper.x):\\n for y in range(lower.y, upper.y):\\n points.append(Point(x, y)) # REFACTOR: Not very efficient\\n\\n return random.sample(points, count)\\n else:\\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))\",\n \"def _sample_using_random(\\n self,\\n p: float = 0.1,\\n ):\\n return sa.func.random() < p\",\n \"def random_transform(self, x, seed=None):\\n # x is a single audio, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\\n input_length = x.shape[img_row_axis]\\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\\n if x.shape[img_row_axis] >= input_length:\\n x = x[:input_length]\\n else:\\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\\n 'constant', constant_values=(0, np.mean(x)))\\n\\n if shift:\\n hx = np.random.uniform(-self.shift, self.shift)\\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\\n\\n if self.roll_range:\\n tx = np.random.uniform(-self.roll_range, self.roll_range)\\n if self.roll_range < 1:\\n tx *= x.shape[img_row_axis]\\n x = np.roll(x, int(tx), axis=(img_row_axis))\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = np.flip(x, axis=img_row_axis)\\n\\n if (self.noise):\\n if np.random.random() < 0.5:\\n if self.noise[-1] == 'Uniform':\\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\\n elif self.noise[-1] == 'Normal':\\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\\n\\n if self.brightness_range is not None:\\n x = random_brightness(x, self.brightness_range)\\n\\n return x\",\n \"def get_transforms(partition: str, num_points: int = 1024,\\n noise_type: str = 'clean', rot_mag: float = 45.0,\\n trans_mag: float = 0.5, partial_p_keep: List = None):\\n\\n partial_p_keep = partial_p_keep if partial_p_keep is not None else [0.7, 0.7]\\n\\n if noise_type == \\\"clean\\\":\\n # 1-1 correspondence for each point (resample first before splitting), no noise\\n if partition == 'train':\\n transforms = [Transforms.Resampler(num_points),\\n Transforms.SplitSourceRef(),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetDeterministic(),\\n Transforms.FixedResampler(num_points),\\n Transforms.SplitSourceRef(),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"jitter\\\":\\n # Points randomly sampled (might not have perfect correspondence), gaussian noise to position\\n if partition == 'train':\\n transforms = [Transforms.SetJitterFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetJitterFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"crop\\\":\\n # Both source and reference point clouds cropped, plus same noise in \\\"jitter\\\"\\n if partition == 'train':\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCrop(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCrop(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"cropinv\\\":\\n # Both source and reference point clouds cropped, plus same noise in \\\"jitter\\\"\\n if partition == 'train':\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCropinv(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCropinv(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n raise NotImplementedError\\n\\n return transforms\",\n \"def randomize(self):\\r\\n # first take care of all parameters (from N(0,1))\\r\\n x = self._get_params_transformed()\\r\\n x = np.random.randn(x.size)\\r\\n self._set_params_transformed(x)\\r\\n # now draw from prior where possible\\r\\n x = self._get_params()\\r\\n if self.priors is not None:\\r\\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\\r\\n self._set_params(x)\\r\\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\\r\",\n \"def flip(p=0.5):\\n return np.random.random() < p\",\n \"def image_rotate(Xb, batch_size):\\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\\n delta = 30. * intensity # scale by self.intensity\\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\\n return Xb\",\n \"def reset(self):\\n newPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\\n self.pot = np.asarray(newPerm)\",\n \"def augmenter(x, y):\\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\\n # as 3D microscopy acquisitions are usually not axially symmetric\\n x, y = random_fliprot(x, y, axis=(1, 2))\\n x = random_intensity_change(x)\\n return x, y\",\n \"def unforeseen():\\r\\n return random.gauss(300., 100.)\",\n \"def rotate_point_cloud_in_plane(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, -sinval, 0],\\n [sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def random():\\n np.random.seed(1939)\",\n \"def randomize(self, amplitude):\\n from random import gauss\\n # update alignment from projections\\n self.getMarkersFromTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\\n\\n # add random amplitude\\n # markers\\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\\n for (imark, mark) in enumerate(self._Markers):\\n if (imark + 1) != irefmark:\\n r = mark.get_r()\\n for ii in range(0, 3):\\n r[ii] = gauss(0, amplitude) + r[ii]\\n self._Markers[imark].set_r(r)\\n\\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\\n # translations, rotations, magnifications\\n for itilt in range(0, self._ntilt):\\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\\n if (self._projIndices[itilt] != ireftilt):\\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\\n\\n # update alignment from projections\\n self.setMarkersInTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\",\n \"def sample_from_belief(self):\\n if self._use_information_bottleneck:\\n posteriors = [torch.distributions.Normal(m, torch.sqrt(s)) for m, s in zip(torch.unbind(self.z_means), torch.unbind(self.z_vars))]\\n z = [d.rsample() for d in posteriors]\\n self.z = torch.stack(z)\\n else:\\n self.z = self.z_means\",\n \"def rndSphere():\\n sph = [0,0,0]\\n \\n sph[2] = random.uniform(-1.0,1.0)\\n z2 = math.sqrt(1.0 - sph[2]*sph[2])\\n phi = (2. * math.pi) * random.random()\\n sph[0] = z2 * math.cos(phi)\\n sph[1] = z2 * math.sin(phi)\\n \\n return sph\",\n \"def importance_sampling_step(self, positions, analytic):\\n \\\"\\\"\\\"With upgrad method for suggetion of new positions.\\\"\\\"\\\"\\n \\\"\\\"\\\"Given through the Langevin equation.\\n D is the diffusion coefficient equal 0.5, xi is a gaussion random\\n variable and delta_t is the time step between 0.001 and 0.01\\\"\\\"\\\"\\n\\n D = 0.5\\n greens_function = 0.0\\n\\n if analytic == True:\\n F_old = self.w.quantum_force(positions)\\n else:\\n F_old = self.w.quantum_force_numerical(positions)\\n\\n # r = random.random()*random.choice((-1, 1))\\n # r = np.random.normal()\\n r = np.zeros(self.num_d)\\n for i in range(self.num_d):\\n r[i] = random.gauss(0, 1)\\n # Pick a random particle and calculate new position\\n random_index = random.randrange(len(positions))\\n new_positions = np.array(positions)\\n\\n term1 = D*F_old[random_index, :]*self.delta_t\\n term2 = r*np.sqrt(self.delta_t)\\n new_random_position = new_positions[random_index, :] + term1 + term2\\n new_positions[random_index, :] = new_random_position\\n\\n # Check if wave function is zero\\n test_wavefunction = self.w.wavefunction(new_positions)\\n if test_wavefunction**2 <= 1e-14:\\n pass\\n else:\\n prob_ratio = self.w.wavefunction_ratio(positions, new_positions)\\n\\n if analytic == True:\\n F_new = self.w.quantum_force(new_positions)\\n else:\\n F_new = self.w.quantum_force_numerical(new_positions)\\n\\n for i in range(self.num_p):\\n for j in range(self.num_d):\\n term1 = 0.5*((F_old[i, j] + F_new[i, j]) *\\n (positions[i, j] - new_positions[i, j]))\\n term2 = D*self.delta_t*(F_old[i, j] - F_new[i, j])\\n greens_function += term1 + term2\\n\\n greens_function = np.exp(greens_function)\\n\\n epsilon = np.random.sample()\\n acceptance_ratio = prob_ratio*greens_function\\n\\n if acceptance_ratio > epsilon:\\n positions = new_positions\\n self.s.distances_update(positions, random_index)\\n self.c += 1.0\\n\\n else:\\n pass\\n\\n return positions\",\n \"def Generate_Random( self ):\\n print( 'Generating Random coordinates' )\\n stands = self.Data.Stand.keys()\\n stands.sort()\\n for s in stands:\\n trees = self.Data.Stand[s].Tree.keys()\\n trees.sort()\\n for t in trees:\\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )\",\n \"def test_randoms():\\n\\n # generate two locusts of points\\n npts = 200\\n epsilon = 0.3\\n # #cluster 1\\n coords1 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\\n coords2 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\\n\\n # generate orientation vectors for cluster 1\\n vectors1 = normalized_vectors(np.random.random((npts, 3)) * 2.0 - 1.0)\\n\\n # define radial bins\\n rbins = np.array([0.0, 0.1, 2.0 * epsilon])\\n s = np.zeros((npts, 3))\\n\\n s[:, 0] = coords2[:, 0] - coords1[:, 0]\\n s[:, 1] = coords2[:, 1] - coords1[:, 1]\\n s[:, 2] = coords2[:, 2] - coords1[:, 2]\\n\\n dist_a = s[:, 0] ** 2 + s[:, 1] ** 2 + s[:, 2] ** 2\\n\\n # define weights appropiate for weighting function\\n weights1 = np.ones((npts, 4))\\n weights1[:, 1] = vectors1[:, 0]\\n weights1[:, 2] = vectors1[:, 1]\\n weights1[:, 3] = vectors1[:, 2]\\n weights2 = np.ones(npts)\\n\\n # weighting 1\\n # calculate weighted counts\\n weighted_counts, counts = positional_marked_npairs_3d(\\n coords1,\\n coords2,\\n rbins,\\n period=None,\\n weights1=weights1,\\n weights2=weights2,\\n weight_func_id=1,\\n num_threads=1,\\n )\\n\\n msg = (\\n \\\"weighted counts do not match expected result given the weighting function\\\"\\n + \\\" \\\"\\n + str(np.max(dist_a))\\n )\\n assert np.isclose(weighted_counts[-1], 0.0 * counts[-1], atol=4000), msg\",\n \"def generate(self) -> np.ndarray:\\n self.sample_r()\\n self.sample_z()\\n ind: np.ndarray = np.less_equal(self.z_sample, self.r_sample)\\n self.r_sample = self.r_sample[ind]\\n self.z_sample = self.z_sample[ind]\\n return np.sort(np.sqrt(np.subtract(np.square(self.r_sample), np.square(self.z_sample))))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6232219","0.61596","0.6088852","0.6088638","0.60208404","0.59796554","0.5843116","0.5838049","0.5800207","0.5765245","0.57596815","0.5757105","0.5742337","0.57243687","0.5712514","0.57068694","0.5703828","0.5692578","0.5684955","0.5684955","0.5684955","0.567044","0.5668316","0.5656708","0.56275225","0.56183785","0.5616456","0.56098604","0.559919","0.5583931","0.55806917","0.55603033","0.5538127","0.5538127","0.55338615","0.5533376","0.5513924","0.5506339","0.5502098","0.54980576","0.5497877","0.549549","0.54914886","0.54912734","0.54828346","0.5482352","0.54821587","0.54794824","0.54779845","0.5473087","0.54726696","0.5470677","0.54467267","0.544418","0.54438883","0.54385275","0.54271686","0.5417527","0.5391912","0.539","0.5389742","0.53892773","0.538549","0.5382139","0.53821266","0.53813535","0.5374746","0.5371321","0.5370104","0.5368116","0.53667176","0.53650427","0.5362146","0.5359498","0.53506416","0.53493357","0.53425837","0.5340214","0.5337004","0.5330375","0.53209245","0.5316836","0.531374","0.5311528","0.5311434","0.5309292","0.53075016","0.5305779","0.53004146","0.52960736","0.52895176","0.5289277","0.5268059","0.5267382","0.526639","0.5261772","0.5256745","0.5256221","0.52549887","0.52494866"],"string":"[\n \"0.6232219\",\n \"0.61596\",\n \"0.6088852\",\n \"0.6088638\",\n \"0.60208404\",\n \"0.59796554\",\n \"0.5843116\",\n \"0.5838049\",\n \"0.5800207\",\n \"0.5765245\",\n \"0.57596815\",\n \"0.5757105\",\n \"0.5742337\",\n \"0.57243687\",\n \"0.5712514\",\n \"0.57068694\",\n \"0.5703828\",\n \"0.5692578\",\n \"0.5684955\",\n \"0.5684955\",\n \"0.5684955\",\n \"0.567044\",\n \"0.5668316\",\n \"0.5656708\",\n \"0.56275225\",\n \"0.56183785\",\n \"0.5616456\",\n \"0.56098604\",\n \"0.559919\",\n \"0.5583931\",\n \"0.55806917\",\n \"0.55603033\",\n \"0.5538127\",\n \"0.5538127\",\n \"0.55338615\",\n \"0.5533376\",\n \"0.5513924\",\n \"0.5506339\",\n \"0.5502098\",\n \"0.54980576\",\n \"0.5497877\",\n \"0.549549\",\n \"0.54914886\",\n \"0.54912734\",\n \"0.54828346\",\n \"0.5482352\",\n \"0.54821587\",\n \"0.54794824\",\n \"0.54779845\",\n \"0.5473087\",\n \"0.54726696\",\n \"0.5470677\",\n \"0.54467267\",\n \"0.544418\",\n \"0.54438883\",\n \"0.54385275\",\n \"0.54271686\",\n \"0.5417527\",\n \"0.5391912\",\n \"0.539\",\n \"0.5389742\",\n \"0.53892773\",\n \"0.538549\",\n \"0.5382139\",\n \"0.53821266\",\n \"0.53813535\",\n \"0.5374746\",\n \"0.5371321\",\n \"0.5370104\",\n \"0.5368116\",\n \"0.53667176\",\n \"0.53650427\",\n \"0.5362146\",\n \"0.5359498\",\n \"0.53506416\",\n \"0.53493357\",\n \"0.53425837\",\n \"0.5340214\",\n \"0.5337004\",\n \"0.5330375\",\n \"0.53209245\",\n \"0.5316836\",\n \"0.531374\",\n \"0.5311528\",\n \"0.5311434\",\n \"0.5309292\",\n \"0.53075016\",\n \"0.5305779\",\n \"0.53004146\",\n \"0.52960736\",\n \"0.52895176\",\n \"0.5289277\",\n \"0.5268059\",\n \"0.5267382\",\n \"0.526639\",\n \"0.5261772\",\n \"0.5256745\",\n \"0.5256221\",\n \"0.52549887\",\n \"0.52494866\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57714236"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":9466,"cells":{"query":{"kind":"string","value":"Rotate the point cloud along up direction with certain angle."},"document":{"kind":"string","value":"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k,:,0:3]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data"},"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 rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[1, 0] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[1, 0] = b\n MV[0, 2] = b\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\n self.MV = MV","def rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[1, 0] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[1, 0] = b\n MV[0, 2] = b\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\n self.MV = MV","def up(self, angle):\n self.pitch(angle)","def change_angle(self, up_or_down):\n self.angle += up_or_down * math.pi / 180","def test_rotate_up(self):\n # Testing 'up' rotation clockwise\n side = 'U'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def rotateZ(self, angle):\r\n if angle:\r\n c = cos(radians(angle))\r\n s = sin(radians(angle))\r\n self.mtrx = dot([[c, s, 0, 0],\r\n [-s, c, 0, 0],\r\n [0, 0, 1, 0],\r\n [0, 0, 0, 1]],\r\n self.mtrx)\r\n self.rtn[2] = angle\r\n self.was_moved = True","def _rotate(self, angle):\n angle *= self._degreesPerAU\n self._orient = self._orient.rotate(angle)","def rotate_point_cloud_by_angle(self, data, rotation_angle):\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n rotated_data = np.dot(data, rotation_matrix)\n\n return rotated_data","def rotate(self, angle):\n old_angle, tilt = self.rotation\n new_angle = old_angle + angle\n while new_angle > 90:\n new_angle = new_angle - 90\n while angle < -90:\n new_angle = new_angle + 90\n self.rotation = (new_angle, tilt)","def rotate(self,angle):\n origin = copy.deepcopy(self._current)\n\n q = [origin.orientation.x,\n origin.orientation.y,\n origin.orientation.z,\n origin.orientation.w] # quaternion nonsense\n\n (roll, pitch, yaw) = euler_from_quaternion(q)\n\n atTarget=False\n\n currentAngle=yaw\n angle=angle+currentAngle\n\n if(angle==currentAngle):\n w=0\n elif(angle>currentAngle):\n w=1\n elif(angle<currentAngle):\n w=-1\n\n move_msg=Twist()\n move_msg.linear.x=0\n move_msg.angular.z=w\n\n\n stop_msg =Twist()\n stop_msg.linear.x=0\n stop_msg.angular.z=0\n\n while(not atTarget and not rospy.is_shutdown()):\n if(currentAngle>=angle):\n atTarget=True\n self._vel_pub.publish(stop_msg)\n print('rotate: stoped')\n else:\n origin = copy.deepcopy(self._current)\n\n q = [origin.orientation.x,\n origin.orientation.y,\n origin.orientation.z,\n origin.orientation.w] # quaternion nonsense\n\n (roll, pitch, yaw) = euler_from_quaternion(q)\n\n currentAngle=yaw\n self._vel_pub.publish(move_msg)\n rospy.sleep(.15)\n print('rotate: moving')\n print('angle: '+str(angle)+'currentAngle: '+str(currentAngle))","def rotate(self, angle, point=None):\n # Actually not working\n if not point:\n point = self.center\n for i in range(len(self.points)):\n self.points[i].rotate(angle, point)","def rotate_about(self, angle, point):\n\t\tif not isinstance(point, Vector2d):\n\t\t\tpoint = Vector2d(*point)\n\t\treturn (self - point).rotate(angle) + point","def rotateZ(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n x = self.x * cosa - self.y * sina\r\n y = self.x * sina + self.y * cosa\r\n return Point3D(x, y, self.z)","def _rotate(self, angle):\n if self.undobuffer:\n self.undobuffer.push((\"rot\", angle, self._degreesPerAU))\n angle *= self._degreesPerAU\n neworient = self._orient.rotate(angle)\n tracing = self.screen._tracing\n if tracing == 1 and self._speed > 0:\n anglevel = 3.0 * self._speed\n steps = 1 + int(abs(angle)/anglevel)\n delta = 1.0*angle/steps\n for _ in range(steps):\n self._orient = self._orient.rotate(delta)\n self._update()\n self._orient = neworient\n self._update()","def rotateVRC(self, vupAngle, uAngle):\n\n # Make a translation matrix to move the point ( VRP + VPN * extent[Z] * 0.5 ) to the origin. Put it in t1.\n t1 = np.matrix( [[1.0, 0.0, 0.0, -1*( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\n [0.0, 1.0, 0.0, -1*( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\n [0.0, 0.0, 1.0, -1*( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\n [0.0, 0.0, 0.0, 1.0] ] )\n # Make an axis alignment matrix Rxyz using u, vup and vpn.\n Rxyz = np.matrix( [[ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a rotation matrix about the Y axis by the VUP angle, put it in r1.\n r1 = np.matrix( [[ np.cos(vupAngle), 0.0, np.sin(vupAngle), 0.0 ],\n [ 0.0, 1.0, 0.0, 0.0 ],\n [ -1*np.sin(vupAngle), 0.0, np.cos(vupAngle), 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a rotation matrix about the X axis by the U angle. Put it in r2.\n r2 = np.matrix( [[ 1.0, 0.0, 0.0, 0.0 ],\n [ 0.0, np.cos(uAngle), -1*np.sin(uAngle), 0.0 ],\n [ 0.0, np.sin(uAngle), np.cos(uAngle), 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a translation matrix that has the opposite translation from step 1.\n t2 = np.matrix( [[1, 0, 0, ( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\n [0, 1, 0, ( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\n [0, 0, 1, ( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\n [0, 0, 0, 1] ] )\n # Make a numpy matrix where the VRP is on the first row, with a 1 in the homogeneous coordinate, \n # and u, vup, and vpn are the next three rows, with a 0 in the homogeneous coordinate.\n tvrc = np.matrix( [[ self.vrp[0, 0], self.vrp[0, 1], self.vrp[0, 2], 1.0 ],\n [ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ] ] )\n # Execute the following: tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\n tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\n # Then copy the values from tvrc back into the VPR, U, VUP, and VPN fields and normalize U, VUP, and VPN.\n self.vrp = tvrc[0,0:3]\n self.u = tvrc[1,0:3]\n self.vup = tvrc[2,0:3]\n self.vpn = tvrc[3,0:3]\n\n #normalize\n self.u = self.normalize(self.u)\n self.vup = self.normalize(self.vup)\n self.vpn = self.normalize(self.vpn)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotate(self,angle):\n radians = (angle * math.pi)/180\n self.direction += angle\n for object in self.objects:\n y = object.position[0]\n x = object.position[1]\n\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)","def srotate(self, angle):\n\n self.angle = self.angle + angle","def rotatedBy(self, angle):\n\t\tx, y = self.x, self.y\n\t\tc, s = cos(angle), sin(angle)\n\t\treturn Vector((c * x) - (s * y), (s * x) + (c * y))","def rotate(self, angle):\n n, a = Vector.polar([self.x, self.y])\n a += angle\n self.x = n * cos(a)\n self.y = n * sin(a)","def rotateZ(self, angle):\n\t\trad = angle * math.pi / 180\n\t\tcosa = math.cos(rad)\n\t\tsina = math.sin(rad)\n\t\tx = self.x * cosa - self.y * sina\n\t\ty = self.x * sina + self.y * cosa\n\t\treturn Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = math.radians(angle)\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslatef(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslatef(*-self.focus)","def rotate(self):\n\n last_center = self.rect.center\n self.image = pg.transform.rotate(self.image_copy,self.angle)\n self.rect = self.image.get_rect()\n self.rect.center = last_center\n self.angle +=self.rotate_by","def test_rotate_up_counter(self):\n # Testing 'up' rotation counter-clockwise\n side = 'Ur'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['g', 'g'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['o', 'o'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['b', 'b'], ['b', 'b']], dtype='<U1'),\n np.array([['r', 'r'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslate(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslate(*-self.focus)","def rotate(self, angle=pi, point=None):\n if not point: point = Point.origin(d=self.dimension)\n v = Vector.createFromTwoPoints(point, self)\n v.rotate(angle)\n self.components = v(point).components","def rotateZ(self, ang):\n if ang != 0.0:\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\n z = self.getZ()\n self.setX(x)\n self.setY(y)\n self.setZ(z)","def rotate(self, angle, aspeed):\n current_pose = [self.px, self.py, self.pth]\n initial_pose = current_pose\n # final pose is the final angle that the robot moves to about z\n final_angle = self.pth+angle\n if final_angle < self.pth:\n aspeed=aspeed*(-1)\n\n final_pose = [self.px, self.py, final_angle]\n \ttolerance = 0.01\n\n self.send_speed(0.0, aspeed)\n while abs(final_pose[2]-current_pose[2]) > tolerance:\n current_pose = [self.px, self.py, self.pth]\n self.send_speed(0.0, 0.0)","def setCameraRotation3D(ang):\n dislin.vup3d(ang)","def down(self, angle):\n self.up(-angle)","def rotate(self, angle, point=None):\n if not point:\n point = self.middle\n self.p1.rotate(angle, point)\n self.p2.rotate(angle, point)","def rotate(self, angle):\n perp = TwoDV(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)","def turn(self, angle=pi, points=[]):\n for point in points:\n point.rotate(angle, self)","def _rotate_about_origin(self, angle, axis):\n matrix = rotation_matrix(angle, axis)\n self._center = matrix.dot(self._center)","def right(self, angle):\r\n self.rotation += angle","def rotate(self, angle):\n self.call('rotate', angle)","def rotate(self, angle):\n perp = Vec2D(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)","def phi_up(self):\n return 0.5 * (self.phi + 10 * (self.phi / 30.0) ** 2) / 180.0 * np.pi","def rotate(self, angle):\r\n radians = angle*pi/180\r\n return Vector(self.x*cos(radians) - self.y*sin(radians),\r\n self.x*sin(radians) + self.y*cos(radians))","def rotate(self, angle):\n rotmat = rotation_matrix_2d(angle)\n rotated = np.dot(rotmat.T, [self.pix_x.value, self.pix_y.value])\n self.pix_x = rotated[0] * self.pix_x.unit\n self.pix_y = rotated[1] * self.pix_x.unit\n self.pix_rotation -= angle","def rotateZ(self, *args, **kwargs):\n ...","def rotate_z(self, angle):\n angle *= np.pi / 180\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\n [np.sin(angle), np.cos(angle), 0],\n [0, 0, 1]]))","def detector_angle(self, angle):\n self.rotate_rad(-radians(angle))","def left(self, angle):\r\n self.rotation -= angle","def rotation(self):\n\t\treturn self.piv.a.rotate.v","def rotate_about(self, rotation, point):\n\t\tif not isinstance(point,Vector3d):\n\t\t\tpoint = Vector3d(*point)\n\t\treturn (self - point).rotate(rotation) + point","def rotate_3dcloud(cloud):\n theta = np.radians(90)\n c, s = np.cos(theta), np.sin(theta)\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\n return cloud.dot(Rx.T)","def _rotate_about_origin(self, angle, axis):\n matrix = rotation_matrix(angle, axis)\n self._normal = matrix.dot(self._normal)\n self._position = matrix.dot(self._position)","def move_up(self):\n self.pitch_motor.step_backward()","def rotate(self, angle):\n image_center = np.array(self.img.shape[1::-1]) / 2\n rot_mat = cv2.getRotationMatrix2D(tuple(image_center), angle, 1.0)\n\n self.img = cv2.warpAffine(\n self.img, rot_mat, self.img.shape[1::-1], flags=cv2.INTER_LINEAR\n )\n\n self.edits.append(f\"rotate:{angle}\")\n return self","def rotate_shape(shape, xy_center, angle_degrees):","def rotateDeg(image, angle):\n angle %= 360.0\n orig_rect = image.get_rect()\n rot_image = pg.transform.rotate(image, angle)\n orig_rect.center = rot_image.get_rect().center\n rot_image = rot_image.subsurface(orig_rect).copy()\n return rot_image","def keypoint_rotate(keypoint, angle, rows, cols, **params):\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\n x, y, a, s = keypoint[:4]\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\n return x, y, a + math.radians(angle), s","def _rotate_about_origin(self, angle, axis):\n print 'Invoked abstract {}._rotate_about_origin({}, {})'.format(\n self, angle, axis)\n return","def rotate(self, angle):\n self._surf = pygame.transform.rotate(self._surf, angle).convert_alpha()","def RotatePointCloud(batch_data):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1],])\n return np.dot(batch_data, rotation_matrix)","def tilt(self, angle):\n rot_angle, old_tilt = self.rotation\n new_tilt = old_tilt + angle\n while new_tilt > 90:\n new_tilt = new_tilt - 90\n while angle < -90:\n new_tilt = new_tilt + 90\n self.rotation = (rot_angle, new_tilt)","def rotate_orbit(self):\n try:\n ang = self.orbit_speed * self.time_scale / self.refresh_rate\n self.obj.rotate(angle=ang, axis=vector(0, 1, 0), origin=self.star.obj.pos)\n self.sum_ang += ang\n except ZeroDivisionError:\n print(\"ERROR: REFRESH_RATE is 0\")\n except (AttributeError, TypeError):\n print(\"ERROR: wrong arguments type while initializing!!\")","def rotate_about_z(self, deg):\n if self.x is None:\n raise AttributeError('rotate_about_z: no X component')\n if self.y is None:\n raise AttributeError('rotate_about_z: no Y component')\n\n sine = sin(radians(deg))\n cosine = cos(radians(deg))\n x_new = self.x*cosine - self.y*sine\n self.y = self.y*cosine + self.x*sine\n self.x = x_new","def _rotate_point_around_point(point, cov_mat, center_point=(0, 0)):\n point_translated = np.array([point[0] - center_point[0], point[1] - center_point[1]])\n point_rot = np.dot(point_translated, cov_mat)\n point_untranslated = point_rot + center_point\n\n return point_untranslated","def vertical_tranverse_rotation(viewpoint):\n # viewpoint ~ position, [yaw, pitch]\n position, principle_axes = torch.split(viewpoint, 3, dim=-1)\n yaw, pitch = torch.split(principle_axes, 1, dim=-1)\n\n viewvector = [position, torch.cos(yaw), torch.sin(yaw), torch.cos(pitch), torch.sin(pitch)]\n viewpoint_hat = torch.cat(viewvector, dim=-1)\n\n return viewpoint_hat","def rotate(self, direction, angle=1.):\n if direction in ('up', 'down'):\n axis = self.side * (1. if direction == 'up' else -1.)\n elif direction in ('left', 'right'):\n axis = self.up * (1. if direction == 'left' else -1.)\n else:\n raise ValueError('Unsupported direction: %s' % direction)\n\n matrix = transform.mat4RotateFromAngleAxis(numpy.radians(angle), *axis)\n newdir = numpy.dot(matrix[:3, :3], self.direction)\n\n if direction in ('up', 'down'):\n # Rotate up to avoid up and new direction to be (almost) co-linear\n newup = numpy.dot(matrix[:3, :3], self.up)\n self.setOrientation(newdir, newup)\n else:\n # No need to rotate up here as it is the rotation axis\n self.direction = newdir","def rotate_rad(self, angle):\n self.beam_angle += angle\n self.xy = rotate(self.xy, angle)\n self.angle += angle","def orient(self,Y):\r\n self.orientation[Y]+=1\r\n if self.orientation[Y]>3:\r\n self.orientation[Y]=0\r\n if self.orientation[Y]<0:\r\n self.orientation[Y]=3\r\n self.can.delete(self.image_bateau[Y])\r\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\r\n self.affichage(Y)","def rotate_in_place(angle):\n action = easy_cozmo._robot.turn_in_place(degrees(-1*angle),speed=degrees(df_rotate_speed))\n try:\n action.wait_for_completed()\n if action.has_succeeded:\n return True\n else:\n code, reason = action.failure_reason\n result = action.result\n print(\"WARNING RotateInPlace: code=%s reason='%s' result=%s\" % (code, reason, result))\n say_error(\"I couldn't rotate, sorry\")\n except Exception as e:\n import traceback\n print(e)\n traceback.print_exc()\n say_error(\"I can't rotate, sorry\")\n try:\n while action.is_running:\n action.abort()\n time.sleep(.5)\n except Exception as e:\n import traceback\n print(e)\n traceback.print_exc()\n say_error(\"Wheels faulty\")\n\n return False","def _rotate_points(x, y, ang):\n theta = np.radians(ang - 90.)\n xNew = x*np.cos(theta) - y*np.sin(theta)\n yNew = x*np.sin(theta) + y*np.cos(theta)\n return xNew, yNew","def rotate(mat,angle):\n return np.dot(Mueller.rotator(angle), np.dot(mat, Mueller.rotator(-angle)))","def rotate(self,center, angle):\n \n self.coord = [x-np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\n\n alpha = angle\n R = np.array([[np.cos(alpha),-np.sin(alpha)],[np.sin(alpha),np.cos(alpha)]])\n \n for i in range(len(self.coord)):\n self.coord[i] = np.squeeze([np.dot([x],R) for x in self.coord[i]])\n\n self.coord = [x+np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\n\n return self","def rotate_z(angle):\n log.dev(\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\")\n\n cosA = np.cos(angle)\n sinA = np.sin(angle)\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\n return R","def rotateY(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n z = self.z * cosa - self.x * sina\r\n x = self.z * sina + self.x * cosa\r\n return Point3D(x, self.y, z)","def rotate(self):\r\n self.rot = (self.vel.y * -3)\r\n if self.rot < -90:\r\n self.rot = -90\r\n \r\n new_image = pg.transform.rotate(self.bird_sprites[self.sprite_frame], self.rot)\r\n old_center = self.rect.center\r\n self.image = new_image\r\n self.rect = self.image.get_rect()\r\n self.rect.center = old_center\r\n # self.animate()\r","def rotate_clockwise(self, angle):\r\n angle = degrees_to_radians(angle)\r\n current_angle = atan(self.x / self.y)\r\n angle += current_angle\r\n\r\n length = self.length\r\n self.x = length*sin(angle)\r\n self.y = length*cos(angle)","def rz(self, angle: float) -> \"Mate\":\n a = angle / 180 * pi\n self.x_dir = Mate._rotate(self.x_dir, self.z_dir, a)\n self.y_dir = Mate._rotate(self.y_dir, self.z_dir, a)\n return self","def rotate(surface, angle, pivot, offset):\n rotated_image = pg.transform.rotozoom(surface, -angle, 1) # Rotate the image.\n rotated_offset = offset.rotate(angle) # Rotate the offset vector.\n # Add the offset vector to the center/pivot point to shift the rect.\n rect = rotated_image.get_rect(center=pivot+rotated_offset)\n return rotated_image, rect # Return the rotated image and shifted rect.","def rotateZ(self, point):\n\n rad = self.offset_rotation.z * math.pi / 180\n\n cosa = math.cos(rad)\n sina = math.sin(rad)\n\n x = point.x * cosa - point.y * sina\n y = point.x * sina + point.y * cosa\n\n return OpenMaya.MVector(x, y, point.z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_points_degrees(points, axis, angle, origin=None):\n return rotate_points(points, axis, radians(angle), origin)","def rotateY(self, angle):\r\n if angle:\r\n c = cos(radians(angle))\r\n s = sin(radians(angle))\r\n self.mtrx = dot([[c, 0, -s, 0],\r\n [0, 1, 0, 0],\r\n [s, 0, c, 0],\r\n [0, 0, 0, 1]],\r\n self.mtrx)\r\n self.rtn[1] = angle\r\n self.was_moved = True","def rotate(origin, point, angle): # Library export\r\n ox, oy = origin\r\n px, py = point\r\n\r\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\r\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\r\n return (qx, qy)","def rotate_by(self, angle, degrees = False):\n\t\ttarget = angle * pi / 180 if degrees else angle\n\t\tif self.inv:\n\t\t\ttarget = -target\n\n\t\tif target > 0:\n\t\t\tn = int(target // self.step_size) + 1\n\t\t\tfor _ in range(n):\n\t\t\t\tself.step_c()\n\n\t\telse:\n\t\t\tn = int(-target // self.step_size) + 1\n\t\t\tfor _ in range(n):\n\t\t\t\tself.step_cc()\n\n\t\tif self.inv:\n\t\t\tdiff = -diff","def rotate(self, angle=0.0):\n # TODO: Implement the rotate function. Remember to record the value of\n # rotation degree.\n self.rotDegree = angle\n self.x = rotate(self.x, angle = angle, axes=(0, 1), reshape=False, \n output=None, order=3, mode='constant', cval=0.0, prefilter=True)\n # This rotation isn't working correctly. Get shit for non right anlge rotatations\n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def rotate(self):\n pass","def rotate_local(self, angle, axis=(0., 0., 1.)):\n self.rotation *= aa2q(angle, glm.vec3(axis))","def _rotate(self):\n new_points = list()\n for i in range(len(self._points)):\n x = self._points[i][0]\n y = self._points[i][1]\n new_x = self._center[0] + self._center[1] - y\n new_y = self._center[1] - self._center[0] + x\n new_points.append((new_x, new_y))\n return new_points","def rotateY(self, angle):\n rad = math.radians(angle)\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotate(self, rotation):\n self.coords = dot(rotation, self.coords)\n return self","def rotate(self, angle, points=None):\n if not isinstance(angle, torch.Tensor):\n angle = self.tensor.new_tensor(angle)\n\n assert angle.shape == torch.Size([3, 3]) or angle.numel() == 1, \\\n f'invalid rotation angle shape {angle.shape}'\n\n if angle.numel() == 1:\n self.tensor[:, 0:3], rot_mat_T = rotation_3d_in_axis(\n self.tensor[:, 0:3],\n angle,\n axis=self.YAW_AXIS,\n return_mat=True)\n else:\n rot_mat_T = angle\n rot_sin = rot_mat_T[2, 0]\n rot_cos = rot_mat_T[0, 0]\n angle = np.arctan2(rot_sin, rot_cos)\n self.tensor[:, 0:3] = self.tensor[:, 0:3] @ rot_mat_T\n\n self.tensor[:, 6] += angle\n\n if points is not None:\n if isinstance(points, torch.Tensor):\n points[:, :3] = points[:, :3] @ rot_mat_T\n elif isinstance(points, np.ndarray):\n rot_mat_T = rot_mat_T.cpu().numpy()\n points[:, :3] = np.dot(points[:, :3], rot_mat_T)\n elif isinstance(points, BasePoints):\n points.rotate(rot_mat_T)\n else:\n raise ValueError\n return points, rot_mat_T","def rotate_turret(self, angle):\n turret_state = String()\n turret_state.data = \"rotate_turret\"\n\n turret_angle = Float32()\n turret_angle.data = angle\n\n self.ros_node.publish(\"/auto/turret/state\", String, turret_state, latching = True)\n self.ros_node.publish(\"/auto/turret/wanted/angle\", Float32, turret_angle, latching = True)\n rospy.loginfo(\"Turret Rotate\")","def up(self, x, y, z):\n self.curr_up = Vector([x, y, z])\n self.ptr.up(x, y, z)","def rotateY(self, angle):\n\t\trad = angle * math.pi / 180\n\t\tcosa = math.cos(rad)\n\t\tsina = math.sin(rad)\n\t\tz = self.z * cosa - self.x * sina\n\t\tx = self.z * sina + self.x * cosa\n\t\treturn Point3D(x, self.y, z)"],"string":"[\n \"def rotateZUp(self):\\n MV = self.MV\\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\\n # set bottom left and bottom right z values to zero:\\n MV[2, 0] = 0\\n MV[2, 2] = 0\\n a = MV[0, 0] # grab top left value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[1, 0] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[1, 0] = b\\n MV[0, 2] = b\\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\\n self.MV = MV\",\n \"def rotateZUp(self):\\n MV = self.MV\\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\\n # set bottom left and bottom right z values to zero:\\n MV[2, 0] = 0\\n MV[2, 2] = 0\\n a = MV[0, 0] # grab top left value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[1, 0] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[1, 0] = b\\n MV[0, 2] = b\\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\\n self.MV = MV\",\n \"def up(self, angle):\\n self.pitch(angle)\",\n \"def change_angle(self, up_or_down):\\n self.angle += up_or_down * math.pi / 180\",\n \"def test_rotate_up(self):\\n # Testing 'up' rotation clockwise\\n side = 'U'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def rotateZ(self, angle):\\r\\n if angle:\\r\\n c = cos(radians(angle))\\r\\n s = sin(radians(angle))\\r\\n self.mtrx = dot([[c, s, 0, 0],\\r\\n [-s, c, 0, 0],\\r\\n [0, 0, 1, 0],\\r\\n [0, 0, 0, 1]],\\r\\n self.mtrx)\\r\\n self.rtn[2] = angle\\r\\n self.was_moved = True\",\n \"def _rotate(self, angle):\\n angle *= self._degreesPerAU\\n self._orient = self._orient.rotate(angle)\",\n \"def rotate_point_cloud_by_angle(self, data, rotation_angle):\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n rotated_data = np.dot(data, rotation_matrix)\\n\\n return rotated_data\",\n \"def rotate(self, angle):\\n old_angle, tilt = self.rotation\\n new_angle = old_angle + angle\\n while new_angle > 90:\\n new_angle = new_angle - 90\\n while angle < -90:\\n new_angle = new_angle + 90\\n self.rotation = (new_angle, tilt)\",\n \"def rotate(self,angle):\\n origin = copy.deepcopy(self._current)\\n\\n q = [origin.orientation.x,\\n origin.orientation.y,\\n origin.orientation.z,\\n origin.orientation.w] # quaternion nonsense\\n\\n (roll, pitch, yaw) = euler_from_quaternion(q)\\n\\n atTarget=False\\n\\n currentAngle=yaw\\n angle=angle+currentAngle\\n\\n if(angle==currentAngle):\\n w=0\\n elif(angle>currentAngle):\\n w=1\\n elif(angle<currentAngle):\\n w=-1\\n\\n move_msg=Twist()\\n move_msg.linear.x=0\\n move_msg.angular.z=w\\n\\n\\n stop_msg =Twist()\\n stop_msg.linear.x=0\\n stop_msg.angular.z=0\\n\\n while(not atTarget and not rospy.is_shutdown()):\\n if(currentAngle>=angle):\\n atTarget=True\\n self._vel_pub.publish(stop_msg)\\n print('rotate: stoped')\\n else:\\n origin = copy.deepcopy(self._current)\\n\\n q = [origin.orientation.x,\\n origin.orientation.y,\\n origin.orientation.z,\\n origin.orientation.w] # quaternion nonsense\\n\\n (roll, pitch, yaw) = euler_from_quaternion(q)\\n\\n currentAngle=yaw\\n self._vel_pub.publish(move_msg)\\n rospy.sleep(.15)\\n print('rotate: moving')\\n print('angle: '+str(angle)+'currentAngle: '+str(currentAngle))\",\n \"def rotate(self, angle, point=None):\\n # Actually not working\\n if not point:\\n point = self.center\\n for i in range(len(self.points)):\\n self.points[i].rotate(angle, point)\",\n \"def rotate_about(self, angle, point):\\n\\t\\tif not isinstance(point, Vector2d):\\n\\t\\t\\tpoint = Vector2d(*point)\\n\\t\\treturn (self - point).rotate(angle) + point\",\n \"def rotateZ(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n x = self.x * cosa - self.y * sina\\r\\n y = self.x * sina + self.y * cosa\\r\\n return Point3D(x, y, self.z)\",\n \"def _rotate(self, angle):\\n if self.undobuffer:\\n self.undobuffer.push((\\\"rot\\\", angle, self._degreesPerAU))\\n angle *= self._degreesPerAU\\n neworient = self._orient.rotate(angle)\\n tracing = self.screen._tracing\\n if tracing == 1 and self._speed > 0:\\n anglevel = 3.0 * self._speed\\n steps = 1 + int(abs(angle)/anglevel)\\n delta = 1.0*angle/steps\\n for _ in range(steps):\\n self._orient = self._orient.rotate(delta)\\n self._update()\\n self._orient = neworient\\n self._update()\",\n \"def rotateVRC(self, vupAngle, uAngle):\\n\\n # Make a translation matrix to move the point ( VRP + VPN * extent[Z] * 0.5 ) to the origin. Put it in t1.\\n t1 = np.matrix( [[1.0, 0.0, 0.0, -1*( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\\n [0.0, 1.0, 0.0, -1*( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\\n [0.0, 0.0, 1.0, -1*( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\\n [0.0, 0.0, 0.0, 1.0] ] )\\n # Make an axis alignment matrix Rxyz using u, vup and vpn.\\n Rxyz = np.matrix( [[ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a rotation matrix about the Y axis by the VUP angle, put it in r1.\\n r1 = np.matrix( [[ np.cos(vupAngle), 0.0, np.sin(vupAngle), 0.0 ],\\n [ 0.0, 1.0, 0.0, 0.0 ],\\n [ -1*np.sin(vupAngle), 0.0, np.cos(vupAngle), 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a rotation matrix about the X axis by the U angle. Put it in r2.\\n r2 = np.matrix( [[ 1.0, 0.0, 0.0, 0.0 ],\\n [ 0.0, np.cos(uAngle), -1*np.sin(uAngle), 0.0 ],\\n [ 0.0, np.sin(uAngle), np.cos(uAngle), 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a translation matrix that has the opposite translation from step 1.\\n t2 = np.matrix( [[1, 0, 0, ( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\\n [0, 1, 0, ( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\\n [0, 0, 1, ( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\\n [0, 0, 0, 1] ] )\\n # Make a numpy matrix where the VRP is on the first row, with a 1 in the homogeneous coordinate, \\n # and u, vup, and vpn are the next three rows, with a 0 in the homogeneous coordinate.\\n tvrc = np.matrix( [[ self.vrp[0, 0], self.vrp[0, 1], self.vrp[0, 2], 1.0 ],\\n [ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ] ] )\\n # Execute the following: tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\\n tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\\n # Then copy the values from tvrc back into the VPR, U, VUP, and VPN fields and normalize U, VUP, and VPN.\\n self.vrp = tvrc[0,0:3]\\n self.u = tvrc[1,0:3]\\n self.vup = tvrc[2,0:3]\\n self.vpn = tvrc[3,0:3]\\n\\n #normalize\\n self.u = self.normalize(self.u)\\n self.vup = self.normalize(self.vup)\\n self.vpn = self.normalize(self.vpn)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotate(self,angle):\\n radians = (angle * math.pi)/180\\n self.direction += angle\\n for object in self.objects:\\n y = object.position[0]\\n x = object.position[1]\\n\\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)\",\n \"def srotate(self, angle):\\n\\n self.angle = self.angle + angle\",\n \"def rotatedBy(self, angle):\\n\\t\\tx, y = self.x, self.y\\n\\t\\tc, s = cos(angle), sin(angle)\\n\\t\\treturn Vector((c * x) - (s * y), (s * x) + (c * y))\",\n \"def rotate(self, angle):\\n n, a = Vector.polar([self.x, self.y])\\n a += angle\\n self.x = n * cos(a)\\n self.y = n * sin(a)\",\n \"def rotateZ(self, angle):\\n\\t\\trad = angle * math.pi / 180\\n\\t\\tcosa = math.cos(rad)\\n\\t\\tsina = math.sin(rad)\\n\\t\\tx = self.x * cosa - self.y * sina\\n\\t\\ty = self.x * sina + self.y * cosa\\n\\t\\treturn Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = math.radians(angle)\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslatef(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslatef(*-self.focus)\",\n \"def rotate(self):\\n\\n last_center = self.rect.center\\n self.image = pg.transform.rotate(self.image_copy,self.angle)\\n self.rect = self.image.get_rect()\\n self.rect.center = last_center\\n self.angle +=self.rotate_by\",\n \"def test_rotate_up_counter(self):\\n # Testing 'up' rotation counter-clockwise\\n side = 'Ur'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['g', 'g'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['o', 'o'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['b', 'b'], ['b', 'b']], dtype='<U1'),\\n np.array([['r', 'r'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslate(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslate(*-self.focus)\",\n \"def rotate(self, angle=pi, point=None):\\n if not point: point = Point.origin(d=self.dimension)\\n v = Vector.createFromTwoPoints(point, self)\\n v.rotate(angle)\\n self.components = v(point).components\",\n \"def rotateZ(self, ang):\\n if ang != 0.0:\\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\\n z = self.getZ()\\n self.setX(x)\\n self.setY(y)\\n self.setZ(z)\",\n \"def rotate(self, angle, aspeed):\\n current_pose = [self.px, self.py, self.pth]\\n initial_pose = current_pose\\n # final pose is the final angle that the robot moves to about z\\n final_angle = self.pth+angle\\n if final_angle < self.pth:\\n aspeed=aspeed*(-1)\\n\\n final_pose = [self.px, self.py, final_angle]\\n \\ttolerance = 0.01\\n\\n self.send_speed(0.0, aspeed)\\n while abs(final_pose[2]-current_pose[2]) > tolerance:\\n current_pose = [self.px, self.py, self.pth]\\n self.send_speed(0.0, 0.0)\",\n \"def setCameraRotation3D(ang):\\n dislin.vup3d(ang)\",\n \"def down(self, angle):\\n self.up(-angle)\",\n \"def rotate(self, angle, point=None):\\n if not point:\\n point = self.middle\\n self.p1.rotate(angle, point)\\n self.p2.rotate(angle, point)\",\n \"def rotate(self, angle):\\n perp = TwoDV(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)\",\n \"def turn(self, angle=pi, points=[]):\\n for point in points:\\n point.rotate(angle, self)\",\n \"def _rotate_about_origin(self, angle, axis):\\n matrix = rotation_matrix(angle, axis)\\n self._center = matrix.dot(self._center)\",\n \"def right(self, angle):\\r\\n self.rotation += angle\",\n \"def rotate(self, angle):\\n self.call('rotate', angle)\",\n \"def rotate(self, angle):\\n perp = Vec2D(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)\",\n \"def phi_up(self):\\n return 0.5 * (self.phi + 10 * (self.phi / 30.0) ** 2) / 180.0 * np.pi\",\n \"def rotate(self, angle):\\r\\n radians = angle*pi/180\\r\\n return Vector(self.x*cos(radians) - self.y*sin(radians),\\r\\n self.x*sin(radians) + self.y*cos(radians))\",\n \"def rotate(self, angle):\\n rotmat = rotation_matrix_2d(angle)\\n rotated = np.dot(rotmat.T, [self.pix_x.value, self.pix_y.value])\\n self.pix_x = rotated[0] * self.pix_x.unit\\n self.pix_y = rotated[1] * self.pix_x.unit\\n self.pix_rotation -= angle\",\n \"def rotateZ(self, *args, **kwargs):\\n ...\",\n \"def rotate_z(self, angle):\\n angle *= np.pi / 180\\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\\n [np.sin(angle), np.cos(angle), 0],\\n [0, 0, 1]]))\",\n \"def detector_angle(self, angle):\\n self.rotate_rad(-radians(angle))\",\n \"def left(self, angle):\\r\\n self.rotation -= angle\",\n \"def rotation(self):\\n\\t\\treturn self.piv.a.rotate.v\",\n \"def rotate_about(self, rotation, point):\\n\\t\\tif not isinstance(point,Vector3d):\\n\\t\\t\\tpoint = Vector3d(*point)\\n\\t\\treturn (self - point).rotate(rotation) + point\",\n \"def rotate_3dcloud(cloud):\\n theta = np.radians(90)\\n c, s = np.cos(theta), np.sin(theta)\\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\\n return cloud.dot(Rx.T)\",\n \"def _rotate_about_origin(self, angle, axis):\\n matrix = rotation_matrix(angle, axis)\\n self._normal = matrix.dot(self._normal)\\n self._position = matrix.dot(self._position)\",\n \"def move_up(self):\\n self.pitch_motor.step_backward()\",\n \"def rotate(self, angle):\\n image_center = np.array(self.img.shape[1::-1]) / 2\\n rot_mat = cv2.getRotationMatrix2D(tuple(image_center), angle, 1.0)\\n\\n self.img = cv2.warpAffine(\\n self.img, rot_mat, self.img.shape[1::-1], flags=cv2.INTER_LINEAR\\n )\\n\\n self.edits.append(f\\\"rotate:{angle}\\\")\\n return self\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def rotateDeg(image, angle):\\n angle %= 360.0\\n orig_rect = image.get_rect()\\n rot_image = pg.transform.rotate(image, angle)\\n orig_rect.center = rot_image.get_rect().center\\n rot_image = rot_image.subsurface(orig_rect).copy()\\n return rot_image\",\n \"def keypoint_rotate(keypoint, angle, rows, cols, **params):\\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\\n x, y, a, s = keypoint[:4]\\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\\n return x, y, a + math.radians(angle), s\",\n \"def _rotate_about_origin(self, angle, axis):\\n print 'Invoked abstract {}._rotate_about_origin({}, {})'.format(\\n self, angle, axis)\\n return\",\n \"def rotate(self, angle):\\n self._surf = pygame.transform.rotate(self._surf, angle).convert_alpha()\",\n \"def RotatePointCloud(batch_data):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1],])\\n return np.dot(batch_data, rotation_matrix)\",\n \"def tilt(self, angle):\\n rot_angle, old_tilt = self.rotation\\n new_tilt = old_tilt + angle\\n while new_tilt > 90:\\n new_tilt = new_tilt - 90\\n while angle < -90:\\n new_tilt = new_tilt + 90\\n self.rotation = (rot_angle, new_tilt)\",\n \"def rotate_orbit(self):\\n try:\\n ang = self.orbit_speed * self.time_scale / self.refresh_rate\\n self.obj.rotate(angle=ang, axis=vector(0, 1, 0), origin=self.star.obj.pos)\\n self.sum_ang += ang\\n except ZeroDivisionError:\\n print(\\\"ERROR: REFRESH_RATE is 0\\\")\\n except (AttributeError, TypeError):\\n print(\\\"ERROR: wrong arguments type while initializing!!\\\")\",\n \"def rotate_about_z(self, deg):\\n if self.x is None:\\n raise AttributeError('rotate_about_z: no X component')\\n if self.y is None:\\n raise AttributeError('rotate_about_z: no Y component')\\n\\n sine = sin(radians(deg))\\n cosine = cos(radians(deg))\\n x_new = self.x*cosine - self.y*sine\\n self.y = self.y*cosine + self.x*sine\\n self.x = x_new\",\n \"def _rotate_point_around_point(point, cov_mat, center_point=(0, 0)):\\n point_translated = np.array([point[0] - center_point[0], point[1] - center_point[1]])\\n point_rot = np.dot(point_translated, cov_mat)\\n point_untranslated = point_rot + center_point\\n\\n return point_untranslated\",\n \"def vertical_tranverse_rotation(viewpoint):\\n # viewpoint ~ position, [yaw, pitch]\\n position, principle_axes = torch.split(viewpoint, 3, dim=-1)\\n yaw, pitch = torch.split(principle_axes, 1, dim=-1)\\n\\n viewvector = [position, torch.cos(yaw), torch.sin(yaw), torch.cos(pitch), torch.sin(pitch)]\\n viewpoint_hat = torch.cat(viewvector, dim=-1)\\n\\n return viewpoint_hat\",\n \"def rotate(self, direction, angle=1.):\\n if direction in ('up', 'down'):\\n axis = self.side * (1. if direction == 'up' else -1.)\\n elif direction in ('left', 'right'):\\n axis = self.up * (1. if direction == 'left' else -1.)\\n else:\\n raise ValueError('Unsupported direction: %s' % direction)\\n\\n matrix = transform.mat4RotateFromAngleAxis(numpy.radians(angle), *axis)\\n newdir = numpy.dot(matrix[:3, :3], self.direction)\\n\\n if direction in ('up', 'down'):\\n # Rotate up to avoid up and new direction to be (almost) co-linear\\n newup = numpy.dot(matrix[:3, :3], self.up)\\n self.setOrientation(newdir, newup)\\n else:\\n # No need to rotate up here as it is the rotation axis\\n self.direction = newdir\",\n \"def rotate_rad(self, angle):\\n self.beam_angle += angle\\n self.xy = rotate(self.xy, angle)\\n self.angle += angle\",\n \"def orient(self,Y):\\r\\n self.orientation[Y]+=1\\r\\n if self.orientation[Y]>3:\\r\\n self.orientation[Y]=0\\r\\n if self.orientation[Y]<0:\\r\\n self.orientation[Y]=3\\r\\n self.can.delete(self.image_bateau[Y])\\r\\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\\r\\n self.affichage(Y)\",\n \"def rotate_in_place(angle):\\n action = easy_cozmo._robot.turn_in_place(degrees(-1*angle),speed=degrees(df_rotate_speed))\\n try:\\n action.wait_for_completed()\\n if action.has_succeeded:\\n return True\\n else:\\n code, reason = action.failure_reason\\n result = action.result\\n print(\\\"WARNING RotateInPlace: code=%s reason='%s' result=%s\\\" % (code, reason, result))\\n say_error(\\\"I couldn't rotate, sorry\\\")\\n except Exception as e:\\n import traceback\\n print(e)\\n traceback.print_exc()\\n say_error(\\\"I can't rotate, sorry\\\")\\n try:\\n while action.is_running:\\n action.abort()\\n time.sleep(.5)\\n except Exception as e:\\n import traceback\\n print(e)\\n traceback.print_exc()\\n say_error(\\\"Wheels faulty\\\")\\n\\n return False\",\n \"def _rotate_points(x, y, ang):\\n theta = np.radians(ang - 90.)\\n xNew = x*np.cos(theta) - y*np.sin(theta)\\n yNew = x*np.sin(theta) + y*np.cos(theta)\\n return xNew, yNew\",\n \"def rotate(mat,angle):\\n return np.dot(Mueller.rotator(angle), np.dot(mat, Mueller.rotator(-angle)))\",\n \"def rotate(self,center, angle):\\n \\n self.coord = [x-np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\\n\\n alpha = angle\\n R = np.array([[np.cos(alpha),-np.sin(alpha)],[np.sin(alpha),np.cos(alpha)]])\\n \\n for i in range(len(self.coord)):\\n self.coord[i] = np.squeeze([np.dot([x],R) for x in self.coord[i]])\\n\\n self.coord = [x+np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\\n\\n return self\",\n \"def rotate_z(angle):\\n log.dev(\\\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\\\")\\n\\n cosA = np.cos(angle)\\n sinA = np.sin(angle)\\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\\n return R\",\n \"def rotateY(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n z = self.z * cosa - self.x * sina\\r\\n x = self.z * sina + self.x * cosa\\r\\n return Point3D(x, self.y, z)\",\n \"def rotate(self):\\r\\n self.rot = (self.vel.y * -3)\\r\\n if self.rot < -90:\\r\\n self.rot = -90\\r\\n \\r\\n new_image = pg.transform.rotate(self.bird_sprites[self.sprite_frame], self.rot)\\r\\n old_center = self.rect.center\\r\\n self.image = new_image\\r\\n self.rect = self.image.get_rect()\\r\\n self.rect.center = old_center\\r\\n # self.animate()\\r\",\n \"def rotate_clockwise(self, angle):\\r\\n angle = degrees_to_radians(angle)\\r\\n current_angle = atan(self.x / self.y)\\r\\n angle += current_angle\\r\\n\\r\\n length = self.length\\r\\n self.x = length*sin(angle)\\r\\n self.y = length*cos(angle)\",\n \"def rz(self, angle: float) -> \\\"Mate\\\":\\n a = angle / 180 * pi\\n self.x_dir = Mate._rotate(self.x_dir, self.z_dir, a)\\n self.y_dir = Mate._rotate(self.y_dir, self.z_dir, a)\\n return self\",\n \"def rotate(surface, angle, pivot, offset):\\n rotated_image = pg.transform.rotozoom(surface, -angle, 1) # Rotate the image.\\n rotated_offset = offset.rotate(angle) # Rotate the offset vector.\\n # Add the offset vector to the center/pivot point to shift the rect.\\n rect = rotated_image.get_rect(center=pivot+rotated_offset)\\n return rotated_image, rect # Return the rotated image and shifted rect.\",\n \"def rotateZ(self, point):\\n\\n rad = self.offset_rotation.z * math.pi / 180\\n\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n\\n x = point.x * cosa - point.y * sina\\n y = point.x * sina + point.y * cosa\\n\\n return OpenMaya.MVector(x, y, point.z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_points_degrees(points, axis, angle, origin=None):\\n return rotate_points(points, axis, radians(angle), origin)\",\n \"def rotateY(self, angle):\\r\\n if angle:\\r\\n c = cos(radians(angle))\\r\\n s = sin(radians(angle))\\r\\n self.mtrx = dot([[c, 0, -s, 0],\\r\\n [0, 1, 0, 0],\\r\\n [s, 0, c, 0],\\r\\n [0, 0, 0, 1]],\\r\\n self.mtrx)\\r\\n self.rtn[1] = angle\\r\\n self.was_moved = True\",\n \"def rotate(origin, point, angle): # Library export\\r\\n ox, oy = origin\\r\\n px, py = point\\r\\n\\r\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\r\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\r\\n return (qx, qy)\",\n \"def rotate_by(self, angle, degrees = False):\\n\\t\\ttarget = angle * pi / 180 if degrees else angle\\n\\t\\tif self.inv:\\n\\t\\t\\ttarget = -target\\n\\n\\t\\tif target > 0:\\n\\t\\t\\tn = int(target // self.step_size) + 1\\n\\t\\t\\tfor _ in range(n):\\n\\t\\t\\t\\tself.step_c()\\n\\n\\t\\telse:\\n\\t\\t\\tn = int(-target // self.step_size) + 1\\n\\t\\t\\tfor _ in range(n):\\n\\t\\t\\t\\tself.step_cc()\\n\\n\\t\\tif self.inv:\\n\\t\\t\\tdiff = -diff\",\n \"def rotate(self, angle=0.0):\\n # TODO: Implement the rotate function. Remember to record the value of\\n # rotation degree.\\n self.rotDegree = angle\\n self.x = rotate(self.x, angle = angle, axes=(0, 1), reshape=False, \\n output=None, order=3, mode='constant', cval=0.0, prefilter=True)\\n # This rotation isn't working correctly. Get shit for non right anlge rotatations\\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def rotate(self):\\n pass\",\n \"def rotate_local(self, angle, axis=(0., 0., 1.)):\\n self.rotation *= aa2q(angle, glm.vec3(axis))\",\n \"def _rotate(self):\\n new_points = list()\\n for i in range(len(self._points)):\\n x = self._points[i][0]\\n y = self._points[i][1]\\n new_x = self._center[0] + self._center[1] - y\\n new_y = self._center[1] - self._center[0] + x\\n new_points.append((new_x, new_y))\\n return new_points\",\n \"def rotateY(self, angle):\\n rad = math.radians(angle)\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotate(self, rotation):\\n self.coords = dot(rotation, self.coords)\\n return self\",\n \"def rotate(self, angle, points=None):\\n if not isinstance(angle, torch.Tensor):\\n angle = self.tensor.new_tensor(angle)\\n\\n assert angle.shape == torch.Size([3, 3]) or angle.numel() == 1, \\\\\\n f'invalid rotation angle shape {angle.shape}'\\n\\n if angle.numel() == 1:\\n self.tensor[:, 0:3], rot_mat_T = rotation_3d_in_axis(\\n self.tensor[:, 0:3],\\n angle,\\n axis=self.YAW_AXIS,\\n return_mat=True)\\n else:\\n rot_mat_T = angle\\n rot_sin = rot_mat_T[2, 0]\\n rot_cos = rot_mat_T[0, 0]\\n angle = np.arctan2(rot_sin, rot_cos)\\n self.tensor[:, 0:3] = self.tensor[:, 0:3] @ rot_mat_T\\n\\n self.tensor[:, 6] += angle\\n\\n if points is not None:\\n if isinstance(points, torch.Tensor):\\n points[:, :3] = points[:, :3] @ rot_mat_T\\n elif isinstance(points, np.ndarray):\\n rot_mat_T = rot_mat_T.cpu().numpy()\\n points[:, :3] = np.dot(points[:, :3], rot_mat_T)\\n elif isinstance(points, BasePoints):\\n points.rotate(rot_mat_T)\\n else:\\n raise ValueError\\n return points, rot_mat_T\",\n \"def rotate_turret(self, angle):\\n turret_state = String()\\n turret_state.data = \\\"rotate_turret\\\"\\n\\n turret_angle = Float32()\\n turret_angle.data = angle\\n\\n self.ros_node.publish(\\\"/auto/turret/state\\\", String, turret_state, latching = True)\\n self.ros_node.publish(\\\"/auto/turret/wanted/angle\\\", Float32, turret_angle, latching = True)\\n rospy.loginfo(\\\"Turret Rotate\\\")\",\n \"def up(self, x, y, z):\\n self.curr_up = Vector([x, y, z])\\n self.ptr.up(x, y, z)\",\n \"def rotateY(self, angle):\\n\\t\\trad = angle * math.pi / 180\\n\\t\\tcosa = math.cos(rad)\\n\\t\\tsina = math.sin(rad)\\n\\t\\tz = self.z * cosa - self.x * sina\\n\\t\\tx = self.z * sina + self.x * cosa\\n\\t\\treturn Point3D(x, self.y, z)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6844331","0.6844331","0.6701853","0.64968896","0.6489468","0.63358444","0.63339704","0.6315883","0.6225028","0.6200144","0.6192065","0.6183062","0.6182096","0.6172054","0.6166697","0.6152675","0.6152675","0.6152675","0.6152675","0.6152249","0.6143772","0.6140584","0.61380124","0.6120648","0.61149096","0.61093384","0.6108844","0.6081061","0.6080191","0.6077111","0.60604256","0.6048027","0.60326564","0.59939426","0.59916085","0.5983539","0.59693515","0.595932","0.5958489","0.5957472","0.5955715","0.59199643","0.5911484","0.5886208","0.587304","0.58515555","0.5850895","0.58362615","0.5834939","0.58174175","0.5790903","0.57787704","0.5759209","0.575536","0.57528126","0.5750596","0.5730395","0.5726367","0.569456","0.56930363","0.5667203","0.56577003","0.5657046","0.5656918","0.56450725","0.5643675","0.5631848","0.5627663","0.56227344","0.56199497","0.5611446","0.5606613","0.5605769","0.56051695","0.5593065","0.55852854","0.558472","0.5568786","0.55615836","0.5557887","0.5557887","0.5557887","0.5557887","0.5553834","0.5553834","0.5553834","0.5547176","0.5542411","0.5537112","0.55324936","0.5527064","0.55264205","0.5526037","0.55197895","0.5519565","0.5517385","0.55112904","0.5509688","0.5508008","0.55049044"],"string":"[\n \"0.6844331\",\n \"0.6844331\",\n \"0.6701853\",\n \"0.64968896\",\n \"0.6489468\",\n \"0.63358444\",\n \"0.63339704\",\n \"0.6315883\",\n \"0.6225028\",\n \"0.6200144\",\n \"0.6192065\",\n \"0.6183062\",\n \"0.6182096\",\n \"0.6172054\",\n \"0.6166697\",\n \"0.6152675\",\n \"0.6152675\",\n \"0.6152675\",\n \"0.6152675\",\n \"0.6152249\",\n \"0.6143772\",\n \"0.6140584\",\n \"0.61380124\",\n \"0.6120648\",\n \"0.61149096\",\n \"0.61093384\",\n \"0.6108844\",\n \"0.6081061\",\n \"0.6080191\",\n \"0.6077111\",\n \"0.60604256\",\n \"0.6048027\",\n \"0.60326564\",\n \"0.59939426\",\n \"0.59916085\",\n \"0.5983539\",\n \"0.59693515\",\n \"0.595932\",\n \"0.5958489\",\n \"0.5957472\",\n \"0.5955715\",\n \"0.59199643\",\n \"0.5911484\",\n \"0.5886208\",\n \"0.587304\",\n \"0.58515555\",\n \"0.5850895\",\n \"0.58362615\",\n \"0.5834939\",\n \"0.58174175\",\n \"0.5790903\",\n \"0.57787704\",\n \"0.5759209\",\n \"0.575536\",\n \"0.57528126\",\n \"0.5750596\",\n \"0.5730395\",\n \"0.5726367\",\n \"0.569456\",\n \"0.56930363\",\n \"0.5667203\",\n \"0.56577003\",\n \"0.5657046\",\n \"0.5656918\",\n \"0.56450725\",\n \"0.5643675\",\n \"0.5631848\",\n \"0.5627663\",\n \"0.56227344\",\n \"0.56199497\",\n \"0.5611446\",\n \"0.5606613\",\n \"0.5605769\",\n \"0.56051695\",\n \"0.5593065\",\n \"0.55852854\",\n \"0.558472\",\n \"0.5568786\",\n \"0.55615836\",\n \"0.5557887\",\n \"0.5557887\",\n \"0.5557887\",\n \"0.5557887\",\n \"0.5553834\",\n \"0.5553834\",\n \"0.5553834\",\n \"0.5547176\",\n \"0.5542411\",\n \"0.5537112\",\n \"0.55324936\",\n \"0.5527064\",\n \"0.55264205\",\n \"0.5526037\",\n \"0.55197895\",\n \"0.5519565\",\n \"0.5517385\",\n \"0.55112904\",\n \"0.5509688\",\n \"0.5508008\",\n \"0.55049044\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57263416"},"document_rank":{"kind":"string","value":"58"}}},{"rowIdx":9467,"cells":{"query":{"kind":"string","value":"Rotate the point cloud along up direction with certain angle."},"document":{"kind":"string","value":"def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]]) # rotate along y axis\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\n return rotated_data"},"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 rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[1, 0] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[1, 0] = b\n MV[0, 2] = b\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\n self.MV = MV","def rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[1, 0] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[1, 0] = b\n MV[0, 2] = b\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\n self.MV = MV","def up(self, angle):\n self.pitch(angle)","def change_angle(self, up_or_down):\n self.angle += up_or_down * math.pi / 180","def test_rotate_up(self):\n # Testing 'up' rotation clockwise\n side = 'U'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def rotateZ(self, angle):\r\n if angle:\r\n c = cos(radians(angle))\r\n s = sin(radians(angle))\r\n self.mtrx = dot([[c, s, 0, 0],\r\n [-s, c, 0, 0],\r\n [0, 0, 1, 0],\r\n [0, 0, 0, 1]],\r\n self.mtrx)\r\n self.rtn[2] = angle\r\n self.was_moved = True","def _rotate(self, angle):\n angle *= self._degreesPerAU\n self._orient = self._orient.rotate(angle)","def rotate_point_cloud_by_angle(self, data, rotation_angle):\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n rotated_data = np.dot(data, rotation_matrix)\n\n return rotated_data","def rotate(self, angle):\n old_angle, tilt = self.rotation\n new_angle = old_angle + angle\n while new_angle > 90:\n new_angle = new_angle - 90\n while angle < -90:\n new_angle = new_angle + 90\n self.rotation = (new_angle, tilt)","def rotate(self,angle):\n origin = copy.deepcopy(self._current)\n\n q = [origin.orientation.x,\n origin.orientation.y,\n origin.orientation.z,\n origin.orientation.w] # quaternion nonsense\n\n (roll, pitch, yaw) = euler_from_quaternion(q)\n\n atTarget=False\n\n currentAngle=yaw\n angle=angle+currentAngle\n\n if(angle==currentAngle):\n w=0\n elif(angle>currentAngle):\n w=1\n elif(angle<currentAngle):\n w=-1\n\n move_msg=Twist()\n move_msg.linear.x=0\n move_msg.angular.z=w\n\n\n stop_msg =Twist()\n stop_msg.linear.x=0\n stop_msg.angular.z=0\n\n while(not atTarget and not rospy.is_shutdown()):\n if(currentAngle>=angle):\n atTarget=True\n self._vel_pub.publish(stop_msg)\n print('rotate: stoped')\n else:\n origin = copy.deepcopy(self._current)\n\n q = [origin.orientation.x,\n origin.orientation.y,\n origin.orientation.z,\n origin.orientation.w] # quaternion nonsense\n\n (roll, pitch, yaw) = euler_from_quaternion(q)\n\n currentAngle=yaw\n self._vel_pub.publish(move_msg)\n rospy.sleep(.15)\n print('rotate: moving')\n print('angle: '+str(angle)+'currentAngle: '+str(currentAngle))","def rotate(self, angle, point=None):\n # Actually not working\n if not point:\n point = self.center\n for i in range(len(self.points)):\n self.points[i].rotate(angle, point)","def rotate_about(self, angle, point):\n\t\tif not isinstance(point, Vector2d):\n\t\t\tpoint = Vector2d(*point)\n\t\treturn (self - point).rotate(angle) + point","def rotateZ(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n x = self.x * cosa - self.y * sina\r\n y = self.x * sina + self.y * cosa\r\n return Point3D(x, y, self.z)","def _rotate(self, angle):\n if self.undobuffer:\n self.undobuffer.push((\"rot\", angle, self._degreesPerAU))\n angle *= self._degreesPerAU\n neworient = self._orient.rotate(angle)\n tracing = self.screen._tracing\n if tracing == 1 and self._speed > 0:\n anglevel = 3.0 * self._speed\n steps = 1 + int(abs(angle)/anglevel)\n delta = 1.0*angle/steps\n for _ in range(steps):\n self._orient = self._orient.rotate(delta)\n self._update()\n self._orient = neworient\n self._update()","def rotateVRC(self, vupAngle, uAngle):\n\n # Make a translation matrix to move the point ( VRP + VPN * extent[Z] * 0.5 ) to the origin. Put it in t1.\n t1 = np.matrix( [[1.0, 0.0, 0.0, -1*( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\n [0.0, 1.0, 0.0, -1*( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\n [0.0, 0.0, 1.0, -1*( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\n [0.0, 0.0, 0.0, 1.0] ] )\n # Make an axis alignment matrix Rxyz using u, vup and vpn.\n Rxyz = np.matrix( [[ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a rotation matrix about the Y axis by the VUP angle, put it in r1.\n r1 = np.matrix( [[ np.cos(vupAngle), 0.0, np.sin(vupAngle), 0.0 ],\n [ 0.0, 1.0, 0.0, 0.0 ],\n [ -1*np.sin(vupAngle), 0.0, np.cos(vupAngle), 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a rotation matrix about the X axis by the U angle. Put it in r2.\n r2 = np.matrix( [[ 1.0, 0.0, 0.0, 0.0 ],\n [ 0.0, np.cos(uAngle), -1*np.sin(uAngle), 0.0 ],\n [ 0.0, np.sin(uAngle), np.cos(uAngle), 0.0 ],\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\n # Make a translation matrix that has the opposite translation from step 1.\n t2 = np.matrix( [[1, 0, 0, ( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\n [0, 1, 0, ( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\n [0, 0, 1, ( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\n [0, 0, 0, 1] ] )\n # Make a numpy matrix where the VRP is on the first row, with a 1 in the homogeneous coordinate, \n # and u, vup, and vpn are the next three rows, with a 0 in the homogeneous coordinate.\n tvrc = np.matrix( [[ self.vrp[0, 0], self.vrp[0, 1], self.vrp[0, 2], 1.0 ],\n [ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ] ] )\n # Execute the following: tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\n tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\n # Then copy the values from tvrc back into the VPR, U, VUP, and VPN fields and normalize U, VUP, and VPN.\n self.vrp = tvrc[0,0:3]\n self.u = tvrc[1,0:3]\n self.vup = tvrc[2,0:3]\n self.vpn = tvrc[3,0:3]\n\n #normalize\n self.u = self.normalize(self.u)\n self.vup = self.normalize(self.vup)\n self.vpn = self.normalize(self.vpn)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotate(self,angle):\n radians = (angle * math.pi)/180\n self.direction += angle\n for object in self.objects:\n y = object.position[0]\n x = object.position[1]\n\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)","def srotate(self, angle):\n\n self.angle = self.angle + angle","def rotatedBy(self, angle):\n\t\tx, y = self.x, self.y\n\t\tc, s = cos(angle), sin(angle)\n\t\treturn Vector((c * x) - (s * y), (s * x) + (c * y))","def rotate(self, angle):\n n, a = Vector.polar([self.x, self.y])\n a += angle\n self.x = n * cos(a)\n self.y = n * sin(a)","def rotateZ(self, angle):\n\t\trad = angle * math.pi / 180\n\t\tcosa = math.cos(rad)\n\t\tsina = math.sin(rad)\n\t\tx = self.x * cosa - self.y * sina\n\t\ty = self.x * sina + self.y * cosa\n\t\treturn Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = math.radians(angle)\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslatef(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslatef(*-self.focus)","def rotate(self):\n\n last_center = self.rect.center\n self.image = pg.transform.rotate(self.image_copy,self.angle)\n self.rect = self.image.get_rect()\n self.rect.center = last_center\n self.angle +=self.rotate_by","def test_rotate_up_counter(self):\n # Testing 'up' rotation counter-clockwise\n side = 'Ur'\n rotation = list(self.cube.rotate_cube(side))\n result = [np.array([['g', 'g'], ['g', 'g']], dtype='<U1'),\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\n np.array([['o', 'o'], ['o', 'o']], dtype='<U1'),\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\n np.array([['b', 'b'], ['b', 'b']], dtype='<U1'),\n np.array([['r', 'r'], ['r', 'r']], dtype='<U1')]\n\n np.testing.assert_array_equal(rotation, result)","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslate(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslate(*-self.focus)","def rotate(self, angle=pi, point=None):\n if not point: point = Point.origin(d=self.dimension)\n v = Vector.createFromTwoPoints(point, self)\n v.rotate(angle)\n self.components = v(point).components","def rotateZ(self, ang):\n if ang != 0.0:\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\n z = self.getZ()\n self.setX(x)\n self.setY(y)\n self.setZ(z)","def rotate(self, angle, aspeed):\n current_pose = [self.px, self.py, self.pth]\n initial_pose = current_pose\n # final pose is the final angle that the robot moves to about z\n final_angle = self.pth+angle\n if final_angle < self.pth:\n aspeed=aspeed*(-1)\n\n final_pose = [self.px, self.py, final_angle]\n \ttolerance = 0.01\n\n self.send_speed(0.0, aspeed)\n while abs(final_pose[2]-current_pose[2]) > tolerance:\n current_pose = [self.px, self.py, self.pth]\n self.send_speed(0.0, 0.0)","def setCameraRotation3D(ang):\n dislin.vup3d(ang)","def down(self, angle):\n self.up(-angle)","def rotate(self, angle, point=None):\n if not point:\n point = self.middle\n self.p1.rotate(angle, point)\n self.p2.rotate(angle, point)","def rotate(self, angle):\n perp = TwoDV(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)","def turn(self, angle=pi, points=[]):\n for point in points:\n point.rotate(angle, self)","def _rotate_about_origin(self, angle, axis):\n matrix = rotation_matrix(angle, axis)\n self._center = matrix.dot(self._center)","def right(self, angle):\r\n self.rotation += angle","def rotate(self, angle):\n self.call('rotate', angle)","def rotate(self, angle):\n perp = Vec2D(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)","def phi_up(self):\n return 0.5 * (self.phi + 10 * (self.phi / 30.0) ** 2) / 180.0 * np.pi","def rotate(self, angle):\r\n radians = angle*pi/180\r\n return Vector(self.x*cos(radians) - self.y*sin(radians),\r\n self.x*sin(radians) + self.y*cos(radians))","def rotate(self, angle):\n rotmat = rotation_matrix_2d(angle)\n rotated = np.dot(rotmat.T, [self.pix_x.value, self.pix_y.value])\n self.pix_x = rotated[0] * self.pix_x.unit\n self.pix_y = rotated[1] * self.pix_x.unit\n self.pix_rotation -= angle","def rotateZ(self, *args, **kwargs):\n ...","def rotate_z(self, angle):\n angle *= np.pi / 180\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\n [np.sin(angle), np.cos(angle), 0],\n [0, 0, 1]]))","def detector_angle(self, angle):\n self.rotate_rad(-radians(angle))","def left(self, angle):\r\n self.rotation -= angle","def rotation(self):\n\t\treturn self.piv.a.rotate.v","def rotate_about(self, rotation, point):\n\t\tif not isinstance(point,Vector3d):\n\t\t\tpoint = Vector3d(*point)\n\t\treturn (self - point).rotate(rotation) + point","def rotate_3dcloud(cloud):\n theta = np.radians(90)\n c, s = np.cos(theta), np.sin(theta)\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\n return cloud.dot(Rx.T)","def _rotate_about_origin(self, angle, axis):\n matrix = rotation_matrix(angle, axis)\n self._normal = matrix.dot(self._normal)\n self._position = matrix.dot(self._position)","def move_up(self):\n self.pitch_motor.step_backward()","def rotate(self, angle):\n image_center = np.array(self.img.shape[1::-1]) / 2\n rot_mat = cv2.getRotationMatrix2D(tuple(image_center), angle, 1.0)\n\n self.img = cv2.warpAffine(\n self.img, rot_mat, self.img.shape[1::-1], flags=cv2.INTER_LINEAR\n )\n\n self.edits.append(f\"rotate:{angle}\")\n return self","def rotate_shape(shape, xy_center, angle_degrees):","def rotateDeg(image, angle):\n angle %= 360.0\n orig_rect = image.get_rect()\n rot_image = pg.transform.rotate(image, angle)\n orig_rect.center = rot_image.get_rect().center\n rot_image = rot_image.subsurface(orig_rect).copy()\n return rot_image","def keypoint_rotate(keypoint, angle, rows, cols, **params):\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\n x, y, a, s = keypoint[:4]\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\n return x, y, a + math.radians(angle), s","def _rotate_about_origin(self, angle, axis):\n print 'Invoked abstract {}._rotate_about_origin({}, {})'.format(\n self, angle, axis)\n return","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k,:,0:3]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate(self, angle):\n self._surf = pygame.transform.rotate(self._surf, angle).convert_alpha()","def RotatePointCloud(batch_data):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1],])\n return np.dot(batch_data, rotation_matrix)","def tilt(self, angle):\n rot_angle, old_tilt = self.rotation\n new_tilt = old_tilt + angle\n while new_tilt > 90:\n new_tilt = new_tilt - 90\n while angle < -90:\n new_tilt = new_tilt + 90\n self.rotation = (rot_angle, new_tilt)","def rotate_orbit(self):\n try:\n ang = self.orbit_speed * self.time_scale / self.refresh_rate\n self.obj.rotate(angle=ang, axis=vector(0, 1, 0), origin=self.star.obj.pos)\n self.sum_ang += ang\n except ZeroDivisionError:\n print(\"ERROR: REFRESH_RATE is 0\")\n except (AttributeError, TypeError):\n print(\"ERROR: wrong arguments type while initializing!!\")","def rotate_about_z(self, deg):\n if self.x is None:\n raise AttributeError('rotate_about_z: no X component')\n if self.y is None:\n raise AttributeError('rotate_about_z: no Y component')\n\n sine = sin(radians(deg))\n cosine = cos(radians(deg))\n x_new = self.x*cosine - self.y*sine\n self.y = self.y*cosine + self.x*sine\n self.x = x_new","def _rotate_point_around_point(point, cov_mat, center_point=(0, 0)):\n point_translated = np.array([point[0] - center_point[0], point[1] - center_point[1]])\n point_rot = np.dot(point_translated, cov_mat)\n point_untranslated = point_rot + center_point\n\n return point_untranslated","def vertical_tranverse_rotation(viewpoint):\n # viewpoint ~ position, [yaw, pitch]\n position, principle_axes = torch.split(viewpoint, 3, dim=-1)\n yaw, pitch = torch.split(principle_axes, 1, dim=-1)\n\n viewvector = [position, torch.cos(yaw), torch.sin(yaw), torch.cos(pitch), torch.sin(pitch)]\n viewpoint_hat = torch.cat(viewvector, dim=-1)\n\n return viewpoint_hat","def rotate(self, direction, angle=1.):\n if direction in ('up', 'down'):\n axis = self.side * (1. if direction == 'up' else -1.)\n elif direction in ('left', 'right'):\n axis = self.up * (1. if direction == 'left' else -1.)\n else:\n raise ValueError('Unsupported direction: %s' % direction)\n\n matrix = transform.mat4RotateFromAngleAxis(numpy.radians(angle), *axis)\n newdir = numpy.dot(matrix[:3, :3], self.direction)\n\n if direction in ('up', 'down'):\n # Rotate up to avoid up and new direction to be (almost) co-linear\n newup = numpy.dot(matrix[:3, :3], self.up)\n self.setOrientation(newdir, newup)\n else:\n # No need to rotate up here as it is the rotation axis\n self.direction = newdir","def rotate_rad(self, angle):\n self.beam_angle += angle\n self.xy = rotate(self.xy, angle)\n self.angle += angle","def orient(self,Y):\r\n self.orientation[Y]+=1\r\n if self.orientation[Y]>3:\r\n self.orientation[Y]=0\r\n if self.orientation[Y]<0:\r\n self.orientation[Y]=3\r\n self.can.delete(self.image_bateau[Y])\r\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\r\n self.affichage(Y)","def rotate_in_place(angle):\n action = easy_cozmo._robot.turn_in_place(degrees(-1*angle),speed=degrees(df_rotate_speed))\n try:\n action.wait_for_completed()\n if action.has_succeeded:\n return True\n else:\n code, reason = action.failure_reason\n result = action.result\n print(\"WARNING RotateInPlace: code=%s reason='%s' result=%s\" % (code, reason, result))\n say_error(\"I couldn't rotate, sorry\")\n except Exception as e:\n import traceback\n print(e)\n traceback.print_exc()\n say_error(\"I can't rotate, sorry\")\n try:\n while action.is_running:\n action.abort()\n time.sleep(.5)\n except Exception as e:\n import traceback\n print(e)\n traceback.print_exc()\n say_error(\"Wheels faulty\")\n\n return False","def _rotate_points(x, y, ang):\n theta = np.radians(ang - 90.)\n xNew = x*np.cos(theta) - y*np.sin(theta)\n yNew = x*np.sin(theta) + y*np.cos(theta)\n return xNew, yNew","def rotate(mat,angle):\n return np.dot(Mueller.rotator(angle), np.dot(mat, Mueller.rotator(-angle)))","def rotate(self,center, angle):\n \n self.coord = [x-np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\n\n alpha = angle\n R = np.array([[np.cos(alpha),-np.sin(alpha)],[np.sin(alpha),np.cos(alpha)]])\n \n for i in range(len(self.coord)):\n self.coord[i] = np.squeeze([np.dot([x],R) for x in self.coord[i]])\n\n self.coord = [x+np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\n\n return self","def rotate_z(angle):\n log.dev(\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\")\n\n cosA = np.cos(angle)\n sinA = np.sin(angle)\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\n return R","def rotateY(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n z = self.z * cosa - self.x * sina\r\n x = self.z * sina + self.x * cosa\r\n return Point3D(x, self.y, z)","def rotate(self):\r\n self.rot = (self.vel.y * -3)\r\n if self.rot < -90:\r\n self.rot = -90\r\n \r\n new_image = pg.transform.rotate(self.bird_sprites[self.sprite_frame], self.rot)\r\n old_center = self.rect.center\r\n self.image = new_image\r\n self.rect = self.image.get_rect()\r\n self.rect.center = old_center\r\n # self.animate()\r","def rotate_clockwise(self, angle):\r\n angle = degrees_to_radians(angle)\r\n current_angle = atan(self.x / self.y)\r\n angle += current_angle\r\n\r\n length = self.length\r\n self.x = length*sin(angle)\r\n self.y = length*cos(angle)","def rz(self, angle: float) -> \"Mate\":\n a = angle / 180 * pi\n self.x_dir = Mate._rotate(self.x_dir, self.z_dir, a)\n self.y_dir = Mate._rotate(self.y_dir, self.z_dir, a)\n return self","def rotate(surface, angle, pivot, offset):\n rotated_image = pg.transform.rotozoom(surface, -angle, 1) # Rotate the image.\n rotated_offset = offset.rotate(angle) # Rotate the offset vector.\n # Add the offset vector to the center/pivot point to shift the rect.\n rect = rotated_image.get_rect(center=pivot+rotated_offset)\n return rotated_image, rect # Return the rotated image and shifted rect.","def rotateZ(self, point):\n\n rad = self.offset_rotation.z * math.pi / 180\n\n cosa = math.cos(rad)\n sina = math.sin(rad)\n\n x = point.x * cosa - point.y * sina\n y = point.x * sina + point.y * cosa\n\n return OpenMaya.MVector(x, y, point.z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotateY(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_by_angle(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_points_degrees(points, axis, angle, origin=None):\n return rotate_points(points, axis, radians(angle), origin)","def rotateY(self, angle):\r\n if angle:\r\n c = cos(radians(angle))\r\n s = sin(radians(angle))\r\n self.mtrx = dot([[c, 0, -s, 0],\r\n [0, 1, 0, 0],\r\n [s, 0, c, 0],\r\n [0, 0, 0, 1]],\r\n self.mtrx)\r\n self.rtn[1] = angle\r\n self.was_moved = True","def rotate(origin, point, angle): # Library export\r\n ox, oy = origin\r\n px, py = point\r\n\r\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\r\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\r\n return (qx, qy)","def rotate_by(self, angle, degrees = False):\n\t\ttarget = angle * pi / 180 if degrees else angle\n\t\tif self.inv:\n\t\t\ttarget = -target\n\n\t\tif target > 0:\n\t\t\tn = int(target // self.step_size) + 1\n\t\t\tfor _ in range(n):\n\t\t\t\tself.step_c()\n\n\t\telse:\n\t\t\tn = int(-target // self.step_size) + 1\n\t\t\tfor _ in range(n):\n\t\t\t\tself.step_cc()\n\n\t\tif self.inv:\n\t\t\tdiff = -diff","def rotate(self, angle=0.0):\n # TODO: Implement the rotate function. Remember to record the value of\n # rotation degree.\n self.rotDegree = angle\n self.x = rotate(self.x, angle = angle, axes=(0, 1), reshape=False, \n output=None, order=3, mode='constant', cval=0.0, prefilter=True)\n # This rotation isn't working correctly. Get shit for non right anlge rotatations\n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def rotate(self):\n pass","def rotate_local(self, angle, axis=(0., 0., 1.)):\n self.rotation *= aa2q(angle, glm.vec3(axis))","def _rotate(self):\n new_points = list()\n for i in range(len(self._points)):\n x = self._points[i][0]\n y = self._points[i][1]\n new_x = self._center[0] + self._center[1] - y\n new_y = self._center[1] - self._center[0] + x\n new_points.append((new_x, new_y))\n return new_points","def rotateY(self, angle):\n rad = math.radians(angle)\n cosa = math.cos(rad)\n sina = math.sin(rad)\n z = self.z * cosa - self.x * sina\n x = self.z * sina + self.x * cosa\n return Point3D(x, self.y, z)","def rotate(self, rotation):\n self.coords = dot(rotation, self.coords)\n return self","def rotate(self, angle, points=None):\n if not isinstance(angle, torch.Tensor):\n angle = self.tensor.new_tensor(angle)\n\n assert angle.shape == torch.Size([3, 3]) or angle.numel() == 1, \\\n f'invalid rotation angle shape {angle.shape}'\n\n if angle.numel() == 1:\n self.tensor[:, 0:3], rot_mat_T = rotation_3d_in_axis(\n self.tensor[:, 0:3],\n angle,\n axis=self.YAW_AXIS,\n return_mat=True)\n else:\n rot_mat_T = angle\n rot_sin = rot_mat_T[2, 0]\n rot_cos = rot_mat_T[0, 0]\n angle = np.arctan2(rot_sin, rot_cos)\n self.tensor[:, 0:3] = self.tensor[:, 0:3] @ rot_mat_T\n\n self.tensor[:, 6] += angle\n\n if points is not None:\n if isinstance(points, torch.Tensor):\n points[:, :3] = points[:, :3] @ rot_mat_T\n elif isinstance(points, np.ndarray):\n rot_mat_T = rot_mat_T.cpu().numpy()\n points[:, :3] = np.dot(points[:, :3], rot_mat_T)\n elif isinstance(points, BasePoints):\n points.rotate(rot_mat_T)\n else:\n raise ValueError\n return points, rot_mat_T","def rotate_turret(self, angle):\n turret_state = String()\n turret_state.data = \"rotate_turret\"\n\n turret_angle = Float32()\n turret_angle.data = angle\n\n self.ros_node.publish(\"/auto/turret/state\", String, turret_state, latching = True)\n self.ros_node.publish(\"/auto/turret/wanted/angle\", Float32, turret_angle, latching = True)\n rospy.loginfo(\"Turret Rotate\")","def up(self, x, y, z):\n self.curr_up = Vector([x, y, z])\n self.ptr.up(x, y, z)","def rotateY(self, angle):\n\t\trad = angle * math.pi / 180\n\t\tcosa = math.cos(rad)\n\t\tsina = math.sin(rad)\n\t\tz = self.z * cosa - self.x * sina\n\t\tx = self.z * sina + self.x * cosa\n\t\treturn Point3D(x, self.y, z)"],"string":"[\n \"def rotateZUp(self):\\n MV = self.MV\\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\\n # set bottom left and bottom right z values to zero:\\n MV[2, 0] = 0\\n MV[2, 2] = 0\\n a = MV[0, 0] # grab top left value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[1, 0] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[1, 0] = b\\n MV[0, 2] = b\\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\\n self.MV = MV\",\n \"def rotateZUp(self):\\n MV = self.MV\\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\\n # set bottom left and bottom right z values to zero:\\n MV[2, 0] = 0\\n MV[2, 2] = 0\\n a = MV[0, 0] # grab top left value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[1, 0] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[1, 0] = b\\n MV[0, 2] = b\\n MV[1, 2] = -a # needs to be -ve of MV[0, 0]\\n self.MV = MV\",\n \"def up(self, angle):\\n self.pitch(angle)\",\n \"def change_angle(self, up_or_down):\\n self.angle += up_or_down * math.pi / 180\",\n \"def test_rotate_up(self):\\n # Testing 'up' rotation clockwise\\n side = 'U'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['o', 'o'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['b', 'b'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['r', 'r'], ['b', 'b']], dtype='<U1'),\\n np.array([['g', 'g'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def rotateZ(self, angle):\\r\\n if angle:\\r\\n c = cos(radians(angle))\\r\\n s = sin(radians(angle))\\r\\n self.mtrx = dot([[c, s, 0, 0],\\r\\n [-s, c, 0, 0],\\r\\n [0, 0, 1, 0],\\r\\n [0, 0, 0, 1]],\\r\\n self.mtrx)\\r\\n self.rtn[2] = angle\\r\\n self.was_moved = True\",\n \"def _rotate(self, angle):\\n angle *= self._degreesPerAU\\n self._orient = self._orient.rotate(angle)\",\n \"def rotate_point_cloud_by_angle(self, data, rotation_angle):\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n rotated_data = np.dot(data, rotation_matrix)\\n\\n return rotated_data\",\n \"def rotate(self, angle):\\n old_angle, tilt = self.rotation\\n new_angle = old_angle + angle\\n while new_angle > 90:\\n new_angle = new_angle - 90\\n while angle < -90:\\n new_angle = new_angle + 90\\n self.rotation = (new_angle, tilt)\",\n \"def rotate(self,angle):\\n origin = copy.deepcopy(self._current)\\n\\n q = [origin.orientation.x,\\n origin.orientation.y,\\n origin.orientation.z,\\n origin.orientation.w] # quaternion nonsense\\n\\n (roll, pitch, yaw) = euler_from_quaternion(q)\\n\\n atTarget=False\\n\\n currentAngle=yaw\\n angle=angle+currentAngle\\n\\n if(angle==currentAngle):\\n w=0\\n elif(angle>currentAngle):\\n w=1\\n elif(angle<currentAngle):\\n w=-1\\n\\n move_msg=Twist()\\n move_msg.linear.x=0\\n move_msg.angular.z=w\\n\\n\\n stop_msg =Twist()\\n stop_msg.linear.x=0\\n stop_msg.angular.z=0\\n\\n while(not atTarget and not rospy.is_shutdown()):\\n if(currentAngle>=angle):\\n atTarget=True\\n self._vel_pub.publish(stop_msg)\\n print('rotate: stoped')\\n else:\\n origin = copy.deepcopy(self._current)\\n\\n q = [origin.orientation.x,\\n origin.orientation.y,\\n origin.orientation.z,\\n origin.orientation.w] # quaternion nonsense\\n\\n (roll, pitch, yaw) = euler_from_quaternion(q)\\n\\n currentAngle=yaw\\n self._vel_pub.publish(move_msg)\\n rospy.sleep(.15)\\n print('rotate: moving')\\n print('angle: '+str(angle)+'currentAngle: '+str(currentAngle))\",\n \"def rotate(self, angle, point=None):\\n # Actually not working\\n if not point:\\n point = self.center\\n for i in range(len(self.points)):\\n self.points[i].rotate(angle, point)\",\n \"def rotate_about(self, angle, point):\\n\\t\\tif not isinstance(point, Vector2d):\\n\\t\\t\\tpoint = Vector2d(*point)\\n\\t\\treturn (self - point).rotate(angle) + point\",\n \"def rotateZ(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n x = self.x * cosa - self.y * sina\\r\\n y = self.x * sina + self.y * cosa\\r\\n return Point3D(x, y, self.z)\",\n \"def _rotate(self, angle):\\n if self.undobuffer:\\n self.undobuffer.push((\\\"rot\\\", angle, self._degreesPerAU))\\n angle *= self._degreesPerAU\\n neworient = self._orient.rotate(angle)\\n tracing = self.screen._tracing\\n if tracing == 1 and self._speed > 0:\\n anglevel = 3.0 * self._speed\\n steps = 1 + int(abs(angle)/anglevel)\\n delta = 1.0*angle/steps\\n for _ in range(steps):\\n self._orient = self._orient.rotate(delta)\\n self._update()\\n self._orient = neworient\\n self._update()\",\n \"def rotateVRC(self, vupAngle, uAngle):\\n\\n # Make a translation matrix to move the point ( VRP + VPN * extent[Z] * 0.5 ) to the origin. Put it in t1.\\n t1 = np.matrix( [[1.0, 0.0, 0.0, -1*( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\\n [0.0, 1.0, 0.0, -1*( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\\n [0.0, 0.0, 1.0, -1*( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\\n [0.0, 0.0, 0.0, 1.0] ] )\\n # Make an axis alignment matrix Rxyz using u, vup and vpn.\\n Rxyz = np.matrix( [[ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a rotation matrix about the Y axis by the VUP angle, put it in r1.\\n r1 = np.matrix( [[ np.cos(vupAngle), 0.0, np.sin(vupAngle), 0.0 ],\\n [ 0.0, 1.0, 0.0, 0.0 ],\\n [ -1*np.sin(vupAngle), 0.0, np.cos(vupAngle), 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a rotation matrix about the X axis by the U angle. Put it in r2.\\n r2 = np.matrix( [[ 1.0, 0.0, 0.0, 0.0 ],\\n [ 0.0, np.cos(uAngle), -1*np.sin(uAngle), 0.0 ],\\n [ 0.0, np.sin(uAngle), np.cos(uAngle), 0.0 ],\\n [ 0.0, 0.0, 0.0, 1.0 ] ] )\\n # Make a translation matrix that has the opposite translation from step 1.\\n t2 = np.matrix( [[1, 0, 0, ( self.vrp[0,0] + self.vpn[0,0] * self.extent[2] * 0.5 )],\\n [0, 1, 0, ( self.vrp[0,1] + self.vpn[0,1] * self.extent[2] * 0.5 )],\\n [0, 0, 1, ( self.vrp[0,2] + self.vpn[0,2] * self.extent[2] * 0.5 )],\\n [0, 0, 0, 1] ] )\\n # Make a numpy matrix where the VRP is on the first row, with a 1 in the homogeneous coordinate, \\n # and u, vup, and vpn are the next three rows, with a 0 in the homogeneous coordinate.\\n tvrc = np.matrix( [[ self.vrp[0, 0], self.vrp[0, 1], self.vrp[0, 2], 1.0 ],\\n [ self.u[0, 0], self.u[0, 1], self.u[0, 2], 0.0 ],\\n [ self.vup[0, 0], self.vup[0, 1], self.vup[0, 2], 0.0 ],\\n [ self.vpn[0, 0], self.vpn[0, 1], self.vpn[0, 2], 0.0 ] ] )\\n # Execute the following: tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\\n tvrc = (t2*Rxyz.T*r2*r1*Rxyz*t1*tvrc.T).T\\n # Then copy the values from tvrc back into the VPR, U, VUP, and VPN fields and normalize U, VUP, and VPN.\\n self.vrp = tvrc[0,0:3]\\n self.u = tvrc[1,0:3]\\n self.vup = tvrc[2,0:3]\\n self.vpn = tvrc[3,0:3]\\n\\n #normalize\\n self.u = self.normalize(self.u)\\n self.vup = self.normalize(self.vup)\\n self.vpn = self.normalize(self.vpn)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotate(self,angle):\\n radians = (angle * math.pi)/180\\n self.direction += angle\\n for object in self.objects:\\n y = object.position[0]\\n x = object.position[1]\\n\\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)\",\n \"def srotate(self, angle):\\n\\n self.angle = self.angle + angle\",\n \"def rotatedBy(self, angle):\\n\\t\\tx, y = self.x, self.y\\n\\t\\tc, s = cos(angle), sin(angle)\\n\\t\\treturn Vector((c * x) - (s * y), (s * x) + (c * y))\",\n \"def rotate(self, angle):\\n n, a = Vector.polar([self.x, self.y])\\n a += angle\\n self.x = n * cos(a)\\n self.y = n * sin(a)\",\n \"def rotateZ(self, angle):\\n\\t\\trad = angle * math.pi / 180\\n\\t\\tcosa = math.cos(rad)\\n\\t\\tsina = math.sin(rad)\\n\\t\\tx = self.x * cosa - self.y * sina\\n\\t\\ty = self.x * sina + self.y * cosa\\n\\t\\treturn Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = math.radians(angle)\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslatef(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslatef(*-self.focus)\",\n \"def rotate(self):\\n\\n last_center = self.rect.center\\n self.image = pg.transform.rotate(self.image_copy,self.angle)\\n self.rect = self.image.get_rect()\\n self.rect.center = last_center\\n self.angle +=self.rotate_by\",\n \"def test_rotate_up_counter(self):\\n # Testing 'up' rotation counter-clockwise\\n side = 'Ur'\\n rotation = list(self.cube.rotate_cube(side))\\n result = [np.array([['g', 'g'], ['g', 'g']], dtype='<U1'),\\n np.array([['y', 'y'], ['y', 'y']], dtype='<U1'),\\n np.array([['o', 'o'], ['o', 'o']], dtype='<U1'),\\n np.array([['w', 'w'], ['w', 'w']], dtype='<U1'),\\n np.array([['b', 'b'], ['b', 'b']], dtype='<U1'),\\n np.array([['r', 'r'], ['r', 'r']], dtype='<U1')]\\n\\n np.testing.assert_array_equal(rotation, result)\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslate(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslate(*-self.focus)\",\n \"def rotate(self, angle=pi, point=None):\\n if not point: point = Point.origin(d=self.dimension)\\n v = Vector.createFromTwoPoints(point, self)\\n v.rotate(angle)\\n self.components = v(point).components\",\n \"def rotateZ(self, ang):\\n if ang != 0.0:\\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\\n z = self.getZ()\\n self.setX(x)\\n self.setY(y)\\n self.setZ(z)\",\n \"def rotate(self, angle, aspeed):\\n current_pose = [self.px, self.py, self.pth]\\n initial_pose = current_pose\\n # final pose is the final angle that the robot moves to about z\\n final_angle = self.pth+angle\\n if final_angle < self.pth:\\n aspeed=aspeed*(-1)\\n\\n final_pose = [self.px, self.py, final_angle]\\n \\ttolerance = 0.01\\n\\n self.send_speed(0.0, aspeed)\\n while abs(final_pose[2]-current_pose[2]) > tolerance:\\n current_pose = [self.px, self.py, self.pth]\\n self.send_speed(0.0, 0.0)\",\n \"def setCameraRotation3D(ang):\\n dislin.vup3d(ang)\",\n \"def down(self, angle):\\n self.up(-angle)\",\n \"def rotate(self, angle, point=None):\\n if not point:\\n point = self.middle\\n self.p1.rotate(angle, point)\\n self.p2.rotate(angle, point)\",\n \"def rotate(self, angle):\\n perp = TwoDV(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)\",\n \"def turn(self, angle=pi, points=[]):\\n for point in points:\\n point.rotate(angle, self)\",\n \"def _rotate_about_origin(self, angle, axis):\\n matrix = rotation_matrix(angle, axis)\\n self._center = matrix.dot(self._center)\",\n \"def right(self, angle):\\r\\n self.rotation += angle\",\n \"def rotate(self, angle):\\n self.call('rotate', angle)\",\n \"def rotate(self, angle):\\n perp = Vec2D(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)\",\n \"def phi_up(self):\\n return 0.5 * (self.phi + 10 * (self.phi / 30.0) ** 2) / 180.0 * np.pi\",\n \"def rotate(self, angle):\\r\\n radians = angle*pi/180\\r\\n return Vector(self.x*cos(radians) - self.y*sin(radians),\\r\\n self.x*sin(radians) + self.y*cos(radians))\",\n \"def rotate(self, angle):\\n rotmat = rotation_matrix_2d(angle)\\n rotated = np.dot(rotmat.T, [self.pix_x.value, self.pix_y.value])\\n self.pix_x = rotated[0] * self.pix_x.unit\\n self.pix_y = rotated[1] * self.pix_x.unit\\n self.pix_rotation -= angle\",\n \"def rotateZ(self, *args, **kwargs):\\n ...\",\n \"def rotate_z(self, angle):\\n angle *= np.pi / 180\\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\\n [np.sin(angle), np.cos(angle), 0],\\n [0, 0, 1]]))\",\n \"def detector_angle(self, angle):\\n self.rotate_rad(-radians(angle))\",\n \"def left(self, angle):\\r\\n self.rotation -= angle\",\n \"def rotation(self):\\n\\t\\treturn self.piv.a.rotate.v\",\n \"def rotate_about(self, rotation, point):\\n\\t\\tif not isinstance(point,Vector3d):\\n\\t\\t\\tpoint = Vector3d(*point)\\n\\t\\treturn (self - point).rotate(rotation) + point\",\n \"def rotate_3dcloud(cloud):\\n theta = np.radians(90)\\n c, s = np.cos(theta), np.sin(theta)\\n Rx = np.array(((1,0,0),(0, c, -s), (0, s, c)))\\n return cloud.dot(Rx.T)\",\n \"def _rotate_about_origin(self, angle, axis):\\n matrix = rotation_matrix(angle, axis)\\n self._normal = matrix.dot(self._normal)\\n self._position = matrix.dot(self._position)\",\n \"def move_up(self):\\n self.pitch_motor.step_backward()\",\n \"def rotate(self, angle):\\n image_center = np.array(self.img.shape[1::-1]) / 2\\n rot_mat = cv2.getRotationMatrix2D(tuple(image_center), angle, 1.0)\\n\\n self.img = cv2.warpAffine(\\n self.img, rot_mat, self.img.shape[1::-1], flags=cv2.INTER_LINEAR\\n )\\n\\n self.edits.append(f\\\"rotate:{angle}\\\")\\n return self\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def rotateDeg(image, angle):\\n angle %= 360.0\\n orig_rect = image.get_rect()\\n rot_image = pg.transform.rotate(image, angle)\\n orig_rect.center = rot_image.get_rect().center\\n rot_image = rot_image.subsurface(orig_rect).copy()\\n return rot_image\",\n \"def keypoint_rotate(keypoint, angle, rows, cols, **params):\\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\\n x, y, a, s = keypoint[:4]\\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\\n return x, y, a + math.radians(angle), s\",\n \"def _rotate_about_origin(self, angle, axis):\\n print 'Invoked abstract {}._rotate_about_origin({}, {})'.format(\\n self, angle, axis)\\n return\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k,:,0:3]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate(self, angle):\\n self._surf = pygame.transform.rotate(self._surf, angle).convert_alpha()\",\n \"def RotatePointCloud(batch_data):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1],])\\n return np.dot(batch_data, rotation_matrix)\",\n \"def tilt(self, angle):\\n rot_angle, old_tilt = self.rotation\\n new_tilt = old_tilt + angle\\n while new_tilt > 90:\\n new_tilt = new_tilt - 90\\n while angle < -90:\\n new_tilt = new_tilt + 90\\n self.rotation = (rot_angle, new_tilt)\",\n \"def rotate_orbit(self):\\n try:\\n ang = self.orbit_speed * self.time_scale / self.refresh_rate\\n self.obj.rotate(angle=ang, axis=vector(0, 1, 0), origin=self.star.obj.pos)\\n self.sum_ang += ang\\n except ZeroDivisionError:\\n print(\\\"ERROR: REFRESH_RATE is 0\\\")\\n except (AttributeError, TypeError):\\n print(\\\"ERROR: wrong arguments type while initializing!!\\\")\",\n \"def rotate_about_z(self, deg):\\n if self.x is None:\\n raise AttributeError('rotate_about_z: no X component')\\n if self.y is None:\\n raise AttributeError('rotate_about_z: no Y component')\\n\\n sine = sin(radians(deg))\\n cosine = cos(radians(deg))\\n x_new = self.x*cosine - self.y*sine\\n self.y = self.y*cosine + self.x*sine\\n self.x = x_new\",\n \"def _rotate_point_around_point(point, cov_mat, center_point=(0, 0)):\\n point_translated = np.array([point[0] - center_point[0], point[1] - center_point[1]])\\n point_rot = np.dot(point_translated, cov_mat)\\n point_untranslated = point_rot + center_point\\n\\n return point_untranslated\",\n \"def vertical_tranverse_rotation(viewpoint):\\n # viewpoint ~ position, [yaw, pitch]\\n position, principle_axes = torch.split(viewpoint, 3, dim=-1)\\n yaw, pitch = torch.split(principle_axes, 1, dim=-1)\\n\\n viewvector = [position, torch.cos(yaw), torch.sin(yaw), torch.cos(pitch), torch.sin(pitch)]\\n viewpoint_hat = torch.cat(viewvector, dim=-1)\\n\\n return viewpoint_hat\",\n \"def rotate(self, direction, angle=1.):\\n if direction in ('up', 'down'):\\n axis = self.side * (1. if direction == 'up' else -1.)\\n elif direction in ('left', 'right'):\\n axis = self.up * (1. if direction == 'left' else -1.)\\n else:\\n raise ValueError('Unsupported direction: %s' % direction)\\n\\n matrix = transform.mat4RotateFromAngleAxis(numpy.radians(angle), *axis)\\n newdir = numpy.dot(matrix[:3, :3], self.direction)\\n\\n if direction in ('up', 'down'):\\n # Rotate up to avoid up and new direction to be (almost) co-linear\\n newup = numpy.dot(matrix[:3, :3], self.up)\\n self.setOrientation(newdir, newup)\\n else:\\n # No need to rotate up here as it is the rotation axis\\n self.direction = newdir\",\n \"def rotate_rad(self, angle):\\n self.beam_angle += angle\\n self.xy = rotate(self.xy, angle)\\n self.angle += angle\",\n \"def orient(self,Y):\\r\\n self.orientation[Y]+=1\\r\\n if self.orientation[Y]>3:\\r\\n self.orientation[Y]=0\\r\\n if self.orientation[Y]<0:\\r\\n self.orientation[Y]=3\\r\\n self.can.delete(self.image_bateau[Y])\\r\\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\\r\\n self.affichage(Y)\",\n \"def rotate_in_place(angle):\\n action = easy_cozmo._robot.turn_in_place(degrees(-1*angle),speed=degrees(df_rotate_speed))\\n try:\\n action.wait_for_completed()\\n if action.has_succeeded:\\n return True\\n else:\\n code, reason = action.failure_reason\\n result = action.result\\n print(\\\"WARNING RotateInPlace: code=%s reason='%s' result=%s\\\" % (code, reason, result))\\n say_error(\\\"I couldn't rotate, sorry\\\")\\n except Exception as e:\\n import traceback\\n print(e)\\n traceback.print_exc()\\n say_error(\\\"I can't rotate, sorry\\\")\\n try:\\n while action.is_running:\\n action.abort()\\n time.sleep(.5)\\n except Exception as e:\\n import traceback\\n print(e)\\n traceback.print_exc()\\n say_error(\\\"Wheels faulty\\\")\\n\\n return False\",\n \"def _rotate_points(x, y, ang):\\n theta = np.radians(ang - 90.)\\n xNew = x*np.cos(theta) - y*np.sin(theta)\\n yNew = x*np.sin(theta) + y*np.cos(theta)\\n return xNew, yNew\",\n \"def rotate(mat,angle):\\n return np.dot(Mueller.rotator(angle), np.dot(mat, Mueller.rotator(-angle)))\",\n \"def rotate(self,center, angle):\\n \\n self.coord = [x-np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\\n\\n alpha = angle\\n R = np.array([[np.cos(alpha),-np.sin(alpha)],[np.sin(alpha),np.cos(alpha)]])\\n \\n for i in range(len(self.coord)):\\n self.coord[i] = np.squeeze([np.dot([x],R) for x in self.coord[i]])\\n\\n self.coord = [x+np.repeat([[center[0],center[1]]],[x.shape[0]],axis = 0) for x in self.coord]\\n\\n return self\",\n \"def rotate_z(angle):\\n log.dev(\\\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\\\")\\n\\n cosA = np.cos(angle)\\n sinA = np.sin(angle)\\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\\n return R\",\n \"def rotateY(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n z = self.z * cosa - self.x * sina\\r\\n x = self.z * sina + self.x * cosa\\r\\n return Point3D(x, self.y, z)\",\n \"def rotate(self):\\r\\n self.rot = (self.vel.y * -3)\\r\\n if self.rot < -90:\\r\\n self.rot = -90\\r\\n \\r\\n new_image = pg.transform.rotate(self.bird_sprites[self.sprite_frame], self.rot)\\r\\n old_center = self.rect.center\\r\\n self.image = new_image\\r\\n self.rect = self.image.get_rect()\\r\\n self.rect.center = old_center\\r\\n # self.animate()\\r\",\n \"def rotate_clockwise(self, angle):\\r\\n angle = degrees_to_radians(angle)\\r\\n current_angle = atan(self.x / self.y)\\r\\n angle += current_angle\\r\\n\\r\\n length = self.length\\r\\n self.x = length*sin(angle)\\r\\n self.y = length*cos(angle)\",\n \"def rz(self, angle: float) -> \\\"Mate\\\":\\n a = angle / 180 * pi\\n self.x_dir = Mate._rotate(self.x_dir, self.z_dir, a)\\n self.y_dir = Mate._rotate(self.y_dir, self.z_dir, a)\\n return self\",\n \"def rotate(surface, angle, pivot, offset):\\n rotated_image = pg.transform.rotozoom(surface, -angle, 1) # Rotate the image.\\n rotated_offset = offset.rotate(angle) # Rotate the offset vector.\\n # Add the offset vector to the center/pivot point to shift the rect.\\n rect = rotated_image.get_rect(center=pivot+rotated_offset)\\n return rotated_image, rect # Return the rotated image and shifted rect.\",\n \"def rotateZ(self, point):\\n\\n rad = self.offset_rotation.z * math.pi / 180\\n\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n\\n x = point.x * cosa - point.y * sina\\n y = point.x * sina + point.y * cosa\\n\\n return OpenMaya.MVector(x, y, point.z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotateY(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_by_angle(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_points_degrees(points, axis, angle, origin=None):\\n return rotate_points(points, axis, radians(angle), origin)\",\n \"def rotateY(self, angle):\\r\\n if angle:\\r\\n c = cos(radians(angle))\\r\\n s = sin(radians(angle))\\r\\n self.mtrx = dot([[c, 0, -s, 0],\\r\\n [0, 1, 0, 0],\\r\\n [s, 0, c, 0],\\r\\n [0, 0, 0, 1]],\\r\\n self.mtrx)\\r\\n self.rtn[1] = angle\\r\\n self.was_moved = True\",\n \"def rotate(origin, point, angle): # Library export\\r\\n ox, oy = origin\\r\\n px, py = point\\r\\n\\r\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\r\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\r\\n return (qx, qy)\",\n \"def rotate_by(self, angle, degrees = False):\\n\\t\\ttarget = angle * pi / 180 if degrees else angle\\n\\t\\tif self.inv:\\n\\t\\t\\ttarget = -target\\n\\n\\t\\tif target > 0:\\n\\t\\t\\tn = int(target // self.step_size) + 1\\n\\t\\t\\tfor _ in range(n):\\n\\t\\t\\t\\tself.step_c()\\n\\n\\t\\telse:\\n\\t\\t\\tn = int(-target // self.step_size) + 1\\n\\t\\t\\tfor _ in range(n):\\n\\t\\t\\t\\tself.step_cc()\\n\\n\\t\\tif self.inv:\\n\\t\\t\\tdiff = -diff\",\n \"def rotate(self, angle=0.0):\\n # TODO: Implement the rotate function. Remember to record the value of\\n # rotation degree.\\n self.rotDegree = angle\\n self.x = rotate(self.x, angle = angle, axes=(0, 1), reshape=False, \\n output=None, order=3, mode='constant', cval=0.0, prefilter=True)\\n # This rotation isn't working correctly. Get shit for non right anlge rotatations\\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def rotate(self):\\n pass\",\n \"def rotate_local(self, angle, axis=(0., 0., 1.)):\\n self.rotation *= aa2q(angle, glm.vec3(axis))\",\n \"def _rotate(self):\\n new_points = list()\\n for i in range(len(self._points)):\\n x = self._points[i][0]\\n y = self._points[i][1]\\n new_x = self._center[0] + self._center[1] - y\\n new_y = self._center[1] - self._center[0] + x\\n new_points.append((new_x, new_y))\\n return new_points\",\n \"def rotateY(self, angle):\\n rad = math.radians(angle)\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n z = self.z * cosa - self.x * sina\\n x = self.z * sina + self.x * cosa\\n return Point3D(x, self.y, z)\",\n \"def rotate(self, rotation):\\n self.coords = dot(rotation, self.coords)\\n return self\",\n \"def rotate(self, angle, points=None):\\n if not isinstance(angle, torch.Tensor):\\n angle = self.tensor.new_tensor(angle)\\n\\n assert angle.shape == torch.Size([3, 3]) or angle.numel() == 1, \\\\\\n f'invalid rotation angle shape {angle.shape}'\\n\\n if angle.numel() == 1:\\n self.tensor[:, 0:3], rot_mat_T = rotation_3d_in_axis(\\n self.tensor[:, 0:3],\\n angle,\\n axis=self.YAW_AXIS,\\n return_mat=True)\\n else:\\n rot_mat_T = angle\\n rot_sin = rot_mat_T[2, 0]\\n rot_cos = rot_mat_T[0, 0]\\n angle = np.arctan2(rot_sin, rot_cos)\\n self.tensor[:, 0:3] = self.tensor[:, 0:3] @ rot_mat_T\\n\\n self.tensor[:, 6] += angle\\n\\n if points is not None:\\n if isinstance(points, torch.Tensor):\\n points[:, :3] = points[:, :3] @ rot_mat_T\\n elif isinstance(points, np.ndarray):\\n rot_mat_T = rot_mat_T.cpu().numpy()\\n points[:, :3] = np.dot(points[:, :3], rot_mat_T)\\n elif isinstance(points, BasePoints):\\n points.rotate(rot_mat_T)\\n else:\\n raise ValueError\\n return points, rot_mat_T\",\n \"def rotate_turret(self, angle):\\n turret_state = String()\\n turret_state.data = \\\"rotate_turret\\\"\\n\\n turret_angle = Float32()\\n turret_angle.data = angle\\n\\n self.ros_node.publish(\\\"/auto/turret/state\\\", String, turret_state, latching = True)\\n self.ros_node.publish(\\\"/auto/turret/wanted/angle\\\", Float32, turret_angle, latching = True)\\n rospy.loginfo(\\\"Turret Rotate\\\")\",\n \"def up(self, x, y, z):\\n self.curr_up = Vector([x, y, z])\\n self.ptr.up(x, y, z)\",\n \"def rotateY(self, angle):\\n\\t\\trad = angle * math.pi / 180\\n\\t\\tcosa = math.cos(rad)\\n\\t\\tsina = math.sin(rad)\\n\\t\\tz = self.z * cosa - self.x * sina\\n\\t\\tx = self.z * sina + self.x * cosa\\n\\t\\treturn Point3D(x, self.y, z)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6844139","0.6844139","0.6701813","0.6496726","0.6489327","0.63356435","0.63336676","0.63157606","0.6224757","0.6200055","0.6191932","0.6182845","0.6181952","0.6171766","0.6166754","0.6152536","0.6152536","0.6152536","0.6152536","0.6152011","0.6143452","0.61403346","0.613778","0.61205167","0.6114764","0.61092323","0.6108438","0.6080964","0.60800713","0.60768765","0.60602546","0.60479397","0.6032517","0.5993726","0.59914446","0.5983303","0.5969158","0.5959078","0.59581923","0.5957162","0.5955525","0.5919932","0.59111685","0.5885973","0.5872807","0.585135","0.5850646","0.5835982","0.58345914","0.58171916","0.57906914","0.5778481","0.5759046","0.5755057","0.575275","0.575037","0.5730265","0.5726101","0.57260936","0.5694483","0.56927896","0.56668955","0.56574446","0.56569904","0.5656823","0.5645016","0.5643617","0.563158","0.5627297","0.5622612","0.5619882","0.5611111","0.5606338","0.5605646","0.56049","0.5592711","0.55850965","0.55844986","0.55686307","0.5561348","0.5557625","0.5557625","0.5557625","0.5557625","0.5553599","0.5553599","0.5553599","0.5547131","0.55421036","0.5536952","0.5532422","0.55267715","0.5525853","0.5525726","0.55194277","0.5519289","0.5517165","0.5511098","0.5509414","0.5507884","0.55046535"],"string":"[\n \"0.6844139\",\n \"0.6844139\",\n \"0.6701813\",\n \"0.6496726\",\n \"0.6489327\",\n \"0.63356435\",\n \"0.63336676\",\n \"0.63157606\",\n \"0.6224757\",\n \"0.6200055\",\n \"0.6191932\",\n \"0.6182845\",\n \"0.6181952\",\n \"0.6171766\",\n \"0.6166754\",\n \"0.6152536\",\n \"0.6152536\",\n \"0.6152536\",\n \"0.6152536\",\n \"0.6152011\",\n \"0.6143452\",\n \"0.61403346\",\n \"0.613778\",\n \"0.61205167\",\n \"0.6114764\",\n \"0.61092323\",\n \"0.6108438\",\n \"0.6080964\",\n \"0.60800713\",\n \"0.60768765\",\n \"0.60602546\",\n \"0.60479397\",\n \"0.6032517\",\n \"0.5993726\",\n \"0.59914446\",\n \"0.5983303\",\n \"0.5969158\",\n \"0.5959078\",\n \"0.59581923\",\n \"0.5957162\",\n \"0.5955525\",\n \"0.5919932\",\n \"0.59111685\",\n \"0.5885973\",\n \"0.5872807\",\n \"0.585135\",\n \"0.5850646\",\n \"0.5835982\",\n \"0.58345914\",\n \"0.58171916\",\n \"0.57906914\",\n \"0.5778481\",\n \"0.5759046\",\n \"0.5755057\",\n \"0.575275\",\n \"0.575037\",\n \"0.5730265\",\n \"0.5726101\",\n \"0.57260936\",\n \"0.5694483\",\n \"0.56927896\",\n \"0.56668955\",\n \"0.56574446\",\n \"0.56569904\",\n \"0.5656823\",\n \"0.5645016\",\n \"0.5643617\",\n \"0.563158\",\n \"0.5627297\",\n \"0.5622612\",\n \"0.5619882\",\n \"0.5611111\",\n \"0.5606338\",\n \"0.5605646\",\n \"0.56049\",\n \"0.5592711\",\n \"0.55850965\",\n \"0.55844986\",\n \"0.55686307\",\n \"0.5561348\",\n \"0.5557625\",\n \"0.5557625\",\n \"0.5557625\",\n \"0.5557625\",\n \"0.5553599\",\n \"0.5553599\",\n \"0.5553599\",\n \"0.5547131\",\n \"0.55421036\",\n \"0.5536952\",\n \"0.5532422\",\n \"0.55267715\",\n \"0.5525853\",\n \"0.5525726\",\n \"0.55194277\",\n \"0.5519289\",\n \"0.5517165\",\n \"0.5511098\",\n \"0.5509414\",\n \"0.5507884\",\n \"0.55046535\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9468,"cells":{"query":{"kind":"string","value":"Randomly perturb the point clouds by small rotations"},"document":{"kind":"string","value":"def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)\n return rotated_data"},"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_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def random_rotation(self, img, p = 0.5):\n if self.decision(p):\n theta = random.randrange(-15, 15)\n phi = random.randrange(-15, 15)\n gamma = random.randrange(-15, 15)\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\n # check if cut is ahve to much dark pixels, more then 20 %\n non_zeros = np.count_nonzero(roi)\n non_zeros_procent = non_zeros / roi.size\n if non_zeros_procent < 0.8:\n pass\n else:\n img = roi\n return img","def rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\n ## https://en.wikipedia.org/wiki/Rotation_matrix\n if(use_rotation_tensor != True):\n angle_range = DEGREES\n x_angle = radians(random.random() * angle_range)\n y_angle = radians(random.random() * angle_range)\n z_angle = radians(random.random() * angle_range)\n\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\n rotation_matrix = torch.mm(rot_y, rot_z)\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \n\n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n \n \n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\n self.rotation_matrix = rotation_matrix\n \n if(save_rotation_tensor):\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\n else: \n batch_size, point_cloud_size, _ = pointcloud_model.shape\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\n return pointcloud_model_rotated[:,:,0:3]","def augment_cloud(Ps):\n \"Augmented params:\"\n pc_augm_scale=0\n pc_augm_rot=1\n pc_augm_mirror_prob=0.5\n pc_augm_jitter=0\n\n M = transforms3d.zooms.zfdir2mat(1)\n if pc_augm_scale > 1:\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\n if pc_augm_rot:\n angle = random.uniform(0, 2*math.pi)\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\n result = []\n for P in Ps:\n P[:,:3] = np.dot(P[:,:3], M.T)\n\n if pc_augm_jitter:\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\n result.append(P)\n return result","def randomPointOnSphere(r):\n x = np.random.normal()\n y = np.random.normal()\n z = np.random.normal()\n point = np.array([x, y, z])\n point *= r/(x**2 + y**2 + z**2)**.5\n return point","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def randomize_trajectory(self):\n self.angle = randint(-360, 360)\n self.speed = randint(1, 5)/2.5","def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\n Rx = np.array([[1,0,0],\n [0,np.cos(angles[0]),-np.sin(angles[0])],\n [0,np.sin(angles[0]),np.cos(angles[0])]])\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\n [0,1,0],\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\n [np.sin(angles[2]),np.cos(angles[2]),0],\n [0,0,1]])\n R = np.dot(Rz, np.dot(Ry,Rx))\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\n return rotated_data","def rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def resample_particles(self):\n # make sure the distribution is normalized\n self.normalize_particles()\n\n newParticles = []\n for i in range(len(self.particle_cloud)):\n # resample the same # of particles\n choice = random_sample()\n # all the particle weights sum to 1\n csum = 0 # cumulative sum\n for particle in self.particle_cloud:\n csum += particle.w\n if csum >= choice:\n # if the random choice fell within the particle's weight\n newParticles.append(deepcopy(particle))\n break\n self.particle_cloud = newParticles","def _sample_k_new(self, cur_y, cur_z):\n N = float(len(self.obs))\n #old_loglik = self._loglik(cur_y, cur_z)\n\n k_new_count = np.random.poisson(self.alpha / N)\n if k_new_count == 0: return False\n \n # modify the feature ownership matrix\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\n # propose feature images by sampling from the prior distribution\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\n \n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def reroll(self):\n self._base_x = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._x_min,\n self.base_point_distribution._x_max\n )\n self._base_y = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._y_min,\n self.base_point_distribution._y_max\n )","def mutate(self, size):\n rand = random.random()\n if rand <= 0.5:\n print u\"changing colour\"\n idx = random.randrange(0, 4)\n value = random.randrange(0, 256)\n colour = list(self.colour)\n colour[idx] = value\n self.colour = tuple(colour)\n else:\n print u\"changing point\"\n idx = random.randrange(0, len(self.points))\n point = generate_point(size[0], size[1])\n self.points[idx] = point","def mutate_point_poly3(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def random_rotate(self):\r\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\r\n flip = rand.randrange(0, 2, 1) # 0, 1\r\n new_seed = copy.deepcopy(self)\r\n # rotate by 90 degrees * rotation (0, 90, 180 270)\r\n new_seed.cells = np.rot90(new_seed.cells, rotation) \r\n if (flip == 1):\r\n # flip upside down\r\n new_seed.cells = np.flipud(new_seed.cells)\r\n new_seed.xspan = new_seed.cells.shape[0]\r\n new_seed.yspan = new_seed.cells.shape[1]\r\n return new_seed","def spread_quaternions(points,num=100,quats_per_step=100):\n quats = np.zeros((num,4))\n rot_points = np.zeros((num,points.shape[0],3))\n quats[0,:] = [0,0,0,1]\n rot_points[0,:,:] = points\n for ix in range(1,num):\n rand_quats = random_quaternions(quats_per_step) \n positioned = rotate_points(points,rand_quats) \n dists = point_dists(rot_points[:ix],positioned)\n new_rot = np.argmax(dists) \n quats[ix,:]=rand_quats[new_rot,:]\n rot_points[ix,:,:] = positioned[new_rot,:,:]\n \n return quats,rot_points","def _sample_lam(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_lam = self.lam\n \n # modify the feature ownership matrix\n self.lam = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.lam = old_lam","def initialise_particle_cloud(self, initialpose):\n # ----- Initialize the particle cloud as an empty array\n self.particlecloud = PoseArray()\n\n \"\"\"Create the noise to multiply by the random Gaussian number that will\n get added to each of the Poses, that are set to a random position\n and orientation around the initial pose\"\"\"\n sensorSigma=3 #variance\n sensorMu=0 #mean\n noise=sensorSigma * numpy.random.randn() + sensorMu\n\n \"\"\"Create a range for the ammount of random Gaussian values to generate \"\"\"\n randomGauss = 10*self.NUMBER_PREDICTED_READINGS\n\n gaussianRandomNumX = []\n gaussianRandomNumY = []\n randomYawArray = []\n\n for i in range (0,randomGauss):\n gaussianRandomNumX.append(random.gauss(0,1))\n gaussianRandomNumY.append(random.gauss(0,1))\n x=random.randint(1,180)\n randomYaw=(math.pi/x)\n randomYawArray.append(randomYaw)\n\n iterator = 0\n\n \"\"\"\n\t Set the particles to a random position and orientation around the initial pose\n \"\"\"\n particleNumber = 10**2 # 10**3 # 10**4 # 10**5 experiment with different ammounts of particles\n\n while iterator < particleNumber:\n particle = Pose()\n particle.position.x = initialpose.pose.pose.position.x + (gaussianRandomNumX[iterator] * noise)\n particle.position.y = initialpose.pose.pose.position.y + (gaussianRandomNumY[iterator] * noise)\n particle.position.z = initialpose.pose.pose.position.z\n particle.orientation = rotateQuaternion(initialpose.pose.pose.orientation, randomYawArray[iterator])\n\n self.particlecloud.poses.append(particle)\n iterator += 1\n\n return self.particlecloud","def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\n for sampling_result, img_meta in zip(sampling_results, img_metas):\n bboxes = sampling_result.pos_bboxes\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\n -amplitude, amplitude)\n # before jittering\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\n # after jittering\n new_cxcy = cxcy + wh * random_offsets[:, :2]\n new_wh = wh * (1 + random_offsets[:, 2:])\n # xywh to xyxy\n new_x1y1 = (new_cxcy - new_wh / 2)\n new_x2y2 = (new_cxcy + new_wh / 2)\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\n # clip bboxes\n max_shape = img_meta['img_shape']\n if max_shape is not None:\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\n\n sampling_result.pos_bboxes = new_bboxes\n return sampling_results","def uniform_random(self) -> None:\n\n size = self.circ_size\n random.seed(self.seed)\n\n gates = [self.h, self.x, self.y, self.z, self.s, self.t, self.cx]\n candidates = set(range(size))\n\n for i in range(size):\n for j in range(size):\n to_apply = random.choice(gates)\n\n num_qubits = 2 if to_apply == self.cx else 1\n targets = random.sample(candidates, num_qubits)\n to_apply(*targets)\n\n if self.meas: self.measure(self.qr, self.cr)","def mutate_point_circ(mutated_genome):\n seed = random.randint(0,3)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_circ(mutated_genome,index)\n elif seed == 1:\n shift_point_circ(mutated_genome,index)\n elif seed == 2:\n move_radius_circ(mutated_genome,index)\n else: #seed == 3:\n shift_radius_circ(mutated_genome,index)","def getRandomCentroids(data_points, k):\n return random.sample(data_points, k)","def generate_random_surface_points() -> List[SurfacePoint]:\n surface_points: List[SurfacePoint] = []\n for _ in range(42):\n surface_point = SurfacePoint(\n idx=uuid.uuid4().hex,\n x=_gen_random_number(),\n y=_gen_random_number(),\n z=_gen_random_number(),\n x_uc_dist=DistUcEnum.uniform,\n x_uc=_gen_random_number(),\n y_uc_dist=DistUcEnum.uniform,\n y_uc=_gen_random_number(),\n z_uc_dist=DistUcEnum.uniform,\n z_uc=_gen_random_number(),\n smooth=0.01,\n formation=\"Formation_0\",\n )\n surface_points.append(surface_point)\n return surface_points","def generate_base_points(num_points, domain_size, density_map=None,\n reflect=True):\n\n def _try_points(num_points, prob):\n prob = np.atleast_3d(prob)\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\n base_pts = []\n N = 0\n while N < num_points:\n pt = np.random.rand(3) # Generate a point\n # Test whether to keep it or not\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\n if np.random.rand(1) <= prob[indx][indy][indz]:\n base_pts.append(pt)\n N += 1\n base_pts = np.array(base_pts)\n return base_pts\n\n if len(domain_size) == 1: # Spherical\n domain_size = np.array(domain_size)\n r = domain_size[0]\n if density_map is None:\n # Make an image of a sphere filled with ones and use _try_points\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, 20] = 0\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to spherical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\n # Reflect base points across perimeter\n if reflect:\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_spherical(r, theta, phi)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 2: # Cylindrical or Disk\n domain_size = np.array(domain_size)\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, :] = 0\n if domain_size[1] == 0: # Disk\n density_map = density_map[:, :, 0]\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to cylindrical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n z = Z*domain_size[1]\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n inds = ~((z > domain_size[1]) + (z < 0))\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n if reflect:\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_cylindrical(r, theta, z)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 3: # Cube or square\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n if domain_size[2] == 0:\n density_map = density_map[:, :, 0]\n base_pts = _try_points(num_points, density_map)\n base_pts = base_pts*domain_size\n if reflect:\n base_pts = reflect_base_points(base_pts, domain_size)\n\n return base_pts","def realize(self):\n if numpy.random.rand() > self._P:\n self._w *= 0.0","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def point_sample(img_meta,\n img_features,\n points,\n proj_mat,\n coord_type,\n img_scale_factor,\n img_crop_offset,\n img_flip,\n img_pad_shape,\n img_shape,\n aligned=True,\n padding_mode='zeros',\n align_corners=True):\n\n # apply transformation based on info in img_meta\n points = apply_3d_transformation(\n points, coord_type, img_meta, reverse=True)\n\n # project points to camera coordinate\n pts_2d = points_cam2img(points, proj_mat)\n\n # img transformation: scale -> crop -> flip\n # the image is resized by img_scale_factor\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\n img_coors -= img_crop_offset\n\n # grid sample, the valid grid range should be in [-1,1]\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\n\n if img_flip:\n # by default we take it as horizontal flip\n # use img_shape before padding for flip\n orig_h, orig_w = img_shape\n coor_x = orig_w - coor_x\n\n h, w = img_pad_shape\n coor_y = coor_y / h * 2 - 1\n coor_x = coor_x / w * 2 - 1\n grid = torch.cat([coor_x, coor_y],\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\n\n # align_corner=True provides higher performance\n mode = 'bilinear' if aligned else 'nearest'\n point_features = F.grid_sample(\n img_features,\n grid,\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners) # 1xCx1xN feats\n\n return point_features.squeeze().t()","def generate_random_point(det):\n xmin, ymin, zmin = det.ActiveVolume().Min()\n xmax, ymax, zmax = det.ActiveVolume().Max()\n return geoalgo.Vector(np.random.random() * (xmax - xmin) + xmin,\n np.random.random() * (ymax - ymin) + ymin,\n np.random.random() * (zmax - zmin) + zmin)","def _generate_pores(self):\n logger.info(\"Place randomly located pores in the domain\")\n #Original Random Point Generator\n #coords = sp.rand(self._Np,3)*[self._Lx,self._Ly,self._Lz]\n #Seeding Code\n coords = np.zeros([self._Np,3])\n #reject points close to boundaries - if False there will be slightly more\n rejection = [False,False,True]\n for j in range(3):\n i = 0\n while i < self._Np:\n coord = np.random.uniform(0,1,1)\n if self._reject(coord) == rejection[j]:\n coords[i][j]=coord\n i += 1\n coords*=np.array([self._Lx,self._Ly,self._Lz])\n #Seeding Code\n #Uniform Random Generator\n #coords = np.array([np.random.uniform(0,self._Lx,self._Np),np.random.uniform(0,self._Ly,self._Np),np.random.uniform(0,self._Lz,self._Np)]).T\n\n self['pore.coords'] = coords\n logger.debug(\"End of method\")","def mutate_point_trig(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_trig(mutated_genome,index)\n else: #seed == 1:\n shift_point_trig(mutated_genome,index)","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def pepper(self, prob=0.08):\n h, w, c = self.img.shape\n for i in range(h):\n for j in range(w):\n if random() < prob:\n self.img[i, j] = 0\n\n self.edits.append(f\"pepper:{prob}\")\n return self","def prep_pointcloud(input_dict,\n root_path,\n voxel_generator,\n target_assigner,\n db_sampler=None,\n max_voxels=20000,\n max_sweeps=10,\n remove_outside_points=False,\n training=True,\n create_targets=True,\n shuffle_points=False,\n remove_unknown=False,\n gt_rotation_noise=(-np.pi / 3, np.pi / 3),\n gt_loc_noise_std=(1.0, 1.0, 1.0),\n global_rotation_noise=(-np.pi / 4, np.pi / 4),\n global_scaling_noise=(0.95, 1.05),\n global_random_rot_range=(0.78, 2.35),\n global_translate_noise_std=(0, 0, 0),\n num_point_features=4,\n anchor_area_threshold=1,\n gt_points_drop=0.0,\n gt_drop_max_keep=10,\n remove_points_after_sample=True,\n anchor_cache=None,\n remove_environment=False,\n random_crop=False,\n reference_detections=None,\n out_size_factor=2,\n use_group_id=False,\n multi_gpu=False,\n min_points_in_gt=-1,\n random_flip_x=True,\n random_flip_y=True,\n sample_importance=1.0,\n out_dtype=np.float32):\n t = time.time()\n class_names = target_assigner.classes\n points = input_dict[\"lidar\"][\"points\"]\n indices = input_dict[\"lidar\"][\"indices\"]\n origins = input_dict[\"lidar\"][\"origins\"]\n if training:\n anno_dict = input_dict[\"lidar\"][\"annotations\"]\n gt_dict = {\n \"gt_boxes\": anno_dict[\"boxes\"],\n \"gt_names\": anno_dict[\"names\"],\n \"gt_importance\": np.ones([anno_dict[\"boxes\"].shape[0]], dtype=anno_dict[\"boxes\"].dtype),\n }\n if \"difficulty\" not in anno_dict:\n difficulty = np.zeros([anno_dict[\"boxes\"].shape[0]],\n dtype=np.int32)\n gt_dict[\"difficulty\"] = difficulty\n else:\n gt_dict[\"difficulty\"] = anno_dict[\"difficulty\"]\n if use_group_id and \"group_ids\" in anno_dict:\n group_ids = anno_dict[\"group_ids\"]\n gt_dict[\"group_ids\"] = group_ids\n calib = None\n if \"calib\" in input_dict:\n calib = input_dict[\"calib\"]\n\n # # Disable these two since we do not do this for NuScenes\n # if reference_detections is not None:\n # assert calib is not None and \"image\" in input_dict\n # C, R, T = box_np_ops.projection_matrix_to_CRT_kitti(P2)\n # frustums = box_np_ops.get_frustum_v2(reference_detections, C)\n # frustums -= T\n # frustums = np.einsum('ij, akj->aki', np.linalg.inv(R), frustums)\n # frustums = box_np_ops.camera_to_lidar(frustums, rect, Trv2c)\n # surfaces = box_np_ops.corner_to_surfaces_3d_jit(frustums)\n # masks = points_in_convex_polygon_3d_jit(points, surfaces)\n # points = points[masks.any(-1)]\n # if remove_outside_points:\n # assert calib is not None\n # image_shape = input_dict[\"image\"][\"image_shape\"]\n # points = box_np_ops.remove_outside_points(\n # points, calib[\"rect\"], calib[\"Trv2c\"], calib[\"P2\"], image_shape)\n\n # # Very interesting attempt\n # # I have tried the same and found it doesn't really work\n # if remove_environment is True and training:\n # selected = kitti.keep_arrays_by_name(gt_names, target_assigner.classes)\n # _dict_select(gt_dict, selected)\n # masks = box_np_ops.points_in_rbbox(points, gt_dict[\"gt_boxes\"])\n # points = points[masks.any(-1)]\n\n metrics = {}\n\n point_indices_to_remove = None\n if training:\n \"\"\"\n boxes_lidar = gt_dict[\"gt_boxes\"]\n bev_map = simplevis.nuscene_vis(points, boxes_lidar)\n cv2.imshow('pre-noise', bev_map)\n \"\"\"\n selected = kitti.drop_arrays_by_name(gt_dict[\"gt_names\"], [\"Denture\"])\n _dict_select(gt_dict, selected)\n if remove_unknown:\n remove_mask = gt_dict[\"difficulty\"] == -1\n \"\"\"\n gt_boxes_remove = gt_boxes[remove_mask]\n gt_boxes_remove[:, 3:6] += 0.25\n points = prep.remove_points_in_boxes(points, gt_boxes_remove)\n \"\"\"\n keep_mask = np.logical_not(remove_mask)\n _dict_select(gt_dict, keep_mask)\n gt_dict.pop(\"difficulty\")\n\n # This part is interesting - we will need to do the same\n if min_points_in_gt > 0:\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\"gt_boxes\"])\n mask = point_counts >= min_points_in_gt\n _dict_select(gt_dict, mask)\n\n gt_boxes_mask = np.array(\n [n in class_names for n in gt_dict[\"gt_names\"]], dtype=np.bool_)\n\n if db_sampler is not None:\n group_ids = None\n if \"group_ids\" in gt_dict:\n group_ids = gt_dict[\"group_ids\"]\n\n sampled_dict = db_sampler.sample_all(\n root_path,\n gt_dict[\"gt_boxes\"],\n gt_dict[\"gt_names\"],\n num_point_features,\n random_crop,\n gt_group_ids=group_ids,\n calib=calib)\n\n if sampled_dict is not None:\n sampled_gt_names = sampled_dict[\"gt_names\"]\n sampled_gt_boxes = sampled_dict[\"gt_boxes\"]\n sampled_points = sampled_dict[\"points\"]\n sampled_gt_masks = sampled_dict[\"gt_masks\"]\n gt_dict[\"gt_names\"] = np.concatenate(\n [gt_dict[\"gt_names\"], sampled_gt_names], axis=0)\n gt_dict[\"gt_boxes\"] = np.concatenate(\n [gt_dict[\"gt_boxes\"], sampled_gt_boxes])\n gt_boxes_mask = np.concatenate(\n [gt_boxes_mask, sampled_gt_masks], axis=0)\n sampled_gt_importance = np.full(\n [sampled_gt_boxes.shape[0]], sample_importance,\n dtype=sampled_gt_boxes.dtype)\n gt_dict[\"gt_importance\"] = np.concatenate(\n [gt_dict[\"gt_importance\"], sampled_gt_importance])\n\n if group_ids is not None:\n sampled_group_ids = sampled_dict[\"group_ids\"]\n gt_dict[\"group_ids\"] = np.concatenate(\n [gt_dict[\"group_ids\"], sampled_group_ids])\n\n # # Commented out because we have a new way of removing points\n # if remove_points_after_sample:\n # masks = box_np_ops.points_in_rbbox(points, sampled_gt_boxes)\n # point_indices_to_remove = np.flatnonzero(masks.any(-1))\n # # # Delay this process so we can use the full point cloud\n # # # when we do the ray stopping algorithm\n # # points = points[np.logical_not(masks.any(-1))]\n\n # # Paste objects behind so that we don't have to update indices\n # points = np.concatenate([sampled_points, points], axis=0)\n points = np.concatenate([points, sampled_points], axis=0)\n\n pc_range = voxel_generator.point_cloud_range\n group_ids = None\n if \"group_ids\" in gt_dict:\n group_ids = gt_dict[\"group_ids\"]\n\n # # Disable this one for now (not used in PointPillars anyways)\n # prep.noise_per_object_v3_(\n # gt_dict[\"gt_boxes\"],\n # points,\n # gt_boxes_mask,\n # rotation_perturb=gt_rotation_noise,\n # center_noise_std=gt_loc_noise_std,\n # global_random_rot_range=global_random_rot_range,\n # group_ids=group_ids,\n # num_try=100)\n\n # should remove unrelated objects after noise per object\n # for k, v in gt_dict.items():\n # print(k, v.shape)\n _dict_select(gt_dict, gt_boxes_mask)\n gt_classes = np.array(\n [class_names.index(n) + 1 for n in gt_dict[\"gt_names\"]],\n dtype=np.int32)\n gt_dict[\"gt_classes\"] = gt_classes\n gt_dict[\"gt_boxes\"], points, origins = prep.random_flip(\n gt_dict[\"gt_boxes\"], points, origins, 0.5, random_flip_x, random_flip_y)\n gt_dict[\"gt_boxes\"], points, origins = prep.global_rotation_v2(\n gt_dict[\"gt_boxes\"], points, origins, *global_rotation_noise)\n gt_dict[\"gt_boxes\"], points, origins = prep.global_scaling_v2(\n gt_dict[\"gt_boxes\"], points, origins, *global_scaling_noise)\n prep.global_translate_(\n gt_dict[\"gt_boxes\"], points, origins, global_translate_noise_std)\n bv_range = voxel_generator.point_cloud_range[[0, 1, 3, 4]]\n mask = prep.filter_gt_box_outside_range_by_center(gt_dict[\"gt_boxes\"], bv_range)\n _dict_select(gt_dict, mask)\n\n # limit rad to [-pi, pi]\n gt_dict[\"gt_boxes\"][:, 6] = box_np_ops.limit_period(\n gt_dict[\"gt_boxes\"][:, 6], offset=0.5, period=2 * np.pi)\n\n # boxes_lidar = gt_dict[\"gt_boxes\"]\n # bev_map = simplevis.nuscene_vis(points, boxes_lidar)\n # cv2.imshow('post-noise', bev_map)\n # cv2.waitKey(0)\n\n # # Disable this for now (not used in PointPillars anyways)\n # if shuffle_points:\n # # shuffle is a little slow.\n # np.random.shuffle(points)\n\n # [0, -40, -3, 70.4, 40, 1]\n voxel_size = voxel_generator.voxel_size\n pc_range = voxel_generator.point_cloud_range\n grid_size = voxel_generator.grid_size\n\n # organize points into lists based on timestamps\n time_stamps = points[indices[:-1], -1] # counting on the fact we do not miss points from any intermediate time_stamps\n time_stamps = (time_stamps[:-1]+time_stamps[1:])/2\n time_stamps = [-1000.0] + time_stamps.tolist() + [1000.0] # add boundaries\n time_stamps = np.array(time_stamps)\n\n # # LL_OCCUPIED, LL_FREE = 0.85, -0.4\n # lo_occupied = np.log(0.7 / (1 - 0.7))\n # lo_free = np.log(0.4 / (1 - 0.4))\n\n # is there are additional points (from database sampling)\n num_original = indices[-1]\n if len(points) > num_original:\n # split data into two half (indexed and un-indexed)\n original_points, sampled_points = points[:num_original], points[num_original:]\n # compute occupancy and masks\n # visibility, original_mask, sampled_mask = mapping.compute_visibility_and_masks(\n # original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size)\n # )\n logodds, original_mask, sampled_mask = mapping.compute_logodds_and_masks(\n original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size) # , lo_occupied, lo_free\n )\n # apply visible mask\n points = np.concatenate((original_points[original_mask], sampled_points[sampled_mask]))\n else:\n # visibility = mapping.compute_visibility(\n # points, origins, time_stamps, pc_range, min(voxel_size)\n # )\n logodds = mapping.compute_logodds(\n points, origins, time_stamps, pc_range, min(voxel_size) #, lo_occupied, lo_free\n )\n\n # T = len(time_stamps)-1\n # visibility = visibility.reshape(T, -1)\n # if T < (1 + max_sweeps):\n # visibility = np.pad(visibility, ((0, (1+max_sweeps)-T), (0,0)), 'edge')\n\n # with open(f'./utils/mapping/examples/{time.time()}.pkl', 'wb') as f:\n # ##\n # pickle.dump(original_points, f)\n # pickle.dump(sampled_points, f)\n # pickle.dump(origins, f)\n # pickle.dump(time_stamps, f)\n # pickle.dump(pc_range, f)\n # pickle.dump(voxel_size, f)\n # ##\n # pickle.dump(occupancy, f)\n # pickle.dump(original_mask, f)\n # pickle.dump(sampled_mask, f)\n\n if training:\n if min_points_in_gt > 0:\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\"gt_boxes\"])\n mask = point_counts >= min_points_in_gt\n _dict_select(gt_dict, mask)\n\n # [352, 400]\n t1 = time.time()\n if not multi_gpu:\n res = voxel_generator.generate(\n points, max_voxels)\n voxels = res[\"voxels\"]\n coordinates = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\n else:\n res = voxel_generator.generate_multi_gpu(\n points, max_voxels)\n voxels = res[\"voxels\"]\n coordinates = res[\"coordinates\"]\n num_points = res[\"num_points_per_voxel\"]\n num_voxels = np.array([res[\"voxel_num\"]], dtype=np.int64)\n metrics[\"voxel_gene_time\"] = time.time() - t1\n example = {\n 'voxels': voxels,\n # 'visibility': visibility,\n 'logodds': logodds, \n 'num_points': num_points,\n 'coordinates': coordinates,\n \"num_voxels\": num_voxels,\n \"metrics\": metrics,\n }\n if calib is not None:\n example[\"calib\"] = calib\n feature_map_size = grid_size[:2] // out_size_factor\n feature_map_size = [*feature_map_size, 1][::-1]\n # print(f'feature_map_size in prep_pointcloud(): {feature_map_size}')\n if anchor_cache is not None:\n # print('having anchor cache')\n anchors = anchor_cache[\"anchors\"]\n anchors_bv = anchor_cache[\"anchors_bv\"]\n anchors_dict = anchor_cache[\"anchors_dict\"]\n matched_thresholds = anchor_cache[\"matched_thresholds\"]\n unmatched_thresholds = anchor_cache[\"unmatched_thresholds\"]\n\n else:\n # print('NOT having anchor cache')\n ret = target_assigner.generate_anchors(feature_map_size)\n anchors = ret[\"anchors\"]\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\n anchors_bv = box_np_ops.rbbox2d_to_near_bbox(\n anchors[:, [0, 1, 3, 4, 6]])\n matched_thresholds = ret[\"matched_thresholds\"]\n unmatched_thresholds = ret[\"unmatched_thresholds\"]\n # print(f'anchors.shape: {anchors.shape}')\n\n example[\"anchors\"] = anchors\n anchors_mask = None\n if anchor_area_threshold >= 0:\n # slow with high resolution. recommend disable this forever.\n coors = coordinates\n dense_voxel_map = box_np_ops.sparse_sum_for_anchors_mask(\n coors, tuple(grid_size[::-1][1:]))\n dense_voxel_map = dense_voxel_map.cumsum(0)\n dense_voxel_map = dense_voxel_map.cumsum(1)\n anchors_area = box_np_ops.fused_get_anchors_area(\n dense_voxel_map, anchors_bv, voxel_size, pc_range, grid_size)\n anchors_mask = anchors_area > anchor_area_threshold\n # example['anchors_mask'] = anchors_mask.astype(np.uint8)\n example['anchors_mask'] = anchors_mask\n # print(\"prep time\", time.time() - t)\n metrics[\"prep_time\"] = time.time() - t\n if not training:\n return example\n example[\"gt_names\"] = gt_dict[\"gt_names\"]\n # voxel_labels = box_np_ops.assign_label_to_voxel(gt_boxes, coordinates,\n # voxel_size, coors_range)\n if create_targets:\n t1 = time.time()\n targets_dict = target_assigner.assign(\n anchors,\n anchors_dict,\n gt_dict[\"gt_boxes\"],\n anchors_mask,\n gt_classes=gt_dict[\"gt_classes\"],\n gt_names=gt_dict[\"gt_names\"],\n matched_thresholds=matched_thresholds,\n unmatched_thresholds=unmatched_thresholds,\n importance=gt_dict[\"gt_importance\"])\n\n \"\"\"\n boxes_lidar = gt_dict[\"gt_boxes\"]\n bev_map = simplevis.nuscene_vis(points, boxes_lidar, gt_dict[\"gt_names\"])\n assigned_anchors = anchors[targets_dict['labels'] > 0]\n ignored_anchors = anchors[targets_dict['labels'] == -1]\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], ignored_anchors, [128, 128, 128], 2)\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], assigned_anchors, [255, 0, 0])\n cv2.imshow('anchors', bev_map)\n cv2.waitKey(0)\n\n boxes_lidar = gt_dict[\"gt_boxes\"]\n pp_map = np.zeros(grid_size[:2], dtype=np.float32)\n voxels_max = np.max(voxels[:, :, 2], axis=1, keepdims=False)\n voxels_min = np.min(voxels[:, :, 2], axis=1, keepdims=False)\n voxels_height = voxels_max - voxels_min\n voxels_height = np.minimum(voxels_height, 4)\n # sns.distplot(voxels_height)\n # plt.show()\n pp_map[coordinates[:, 1], coordinates[:, 2]] = voxels_height / 4\n pp_map = (pp_map * 255).astype(np.uint8)\n pp_map = cv2.cvtColor(pp_map, cv2.COLOR_GRAY2RGB)\n pp_map = simplevis.draw_box_in_bev(pp_map, [-50, -50, 3, 50, 50, 1], boxes_lidar, [128, 0, 128], 1)\n cv2.imshow('heights', pp_map)\n cv2.waitKey(0)\n \"\"\"\n example.update({\n 'labels': targets_dict['labels'],\n 'reg_targets': targets_dict['bbox_targets'],\n # 'reg_weights': targets_dict['bbox_outside_weights'],\n 'importance': targets_dict['importance'],\n })\n return example","def randomize(self):\n\t\tif self.hasRandomizedAmplitudes:\n\t\t\tself.unrandomize()\n\t\tself.randoms = np.random.multivariate_normal(np.zeros((2*self.totalBins)), self.coma)\n\t\tfor i in range(self.totalBins):\n\t\t\tself.reals[i] += self.randoms[2*i ]\n\t\t\tself.imags[i] += self.randoms[2*i+1]\n\t\tself.hasRandomizedAmplitudes = True","def reset(self):\n self.x = random.uniform(-0.05, 0.05)\n self.x_dot = random.uniform(-0.05, 0.05)\n self.theta = random.uniform(-0.05, 0.05)\n self.theta_dot = random.uniform(-0.05, 0.05)","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def elapseTime(self, gameState):\n newParticleList = []\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\n # likely the ghost is to move to that position\n for particle in self.particles:\n newPosDist = self.getPositionDistribution(gameState, particle)\n newParticleList.append(util.sample(newPosDist))\n self.particles = newParticleList","def mutate_point_poly(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 3: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def JitterPoints(points, sigma=0.01): \n C = 3\n assert(points.shape[1] == C)\n\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\n return points + randJitters","def MovePoint(pos,points,s=0.5, k = 1000): \n \n x = [pos[0]] \n y = [pos[1]]\n rdm.seed(1) # comment out if you want randomness\n for i in range(k):\n n = len(points)\n r = int(rdm.random()*n)\n \n x.append(x[i] + (points[r][0] - x[i]) * s)\n y.append(y[i] + (points[r][1] - y[i]) * s)\n\n \n return(x,y)","def test_rotating_phantom(self):\n cheese = TomoCheese.from_demo_images()\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\n for img in cheese.dicom_stack:\n img.array = rotate(img.array, angle=3, mode=\"edge\")\n cheese.analyze()\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def random_translation(canvas, img):","def _sample_z(self, a):\n r = np.random.rand()\n return ((1 + r * (a - 1))**2) / a","def _get_random_transform(self, img_shape, seed=None):\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if self.rotation_range:\n theta = np.random.uniform(\n -self.rotation_range,\n self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n try: # 1-D array-like or int\n tx = np.random.choice(self.height_shift_range)\n tx *= np.random.choice([-1, 1])\n except ValueError: # floating point\n tx = np.random.uniform(-self.height_shift_range,\n self.height_shift_range)\n if np.max(self.height_shift_range) < 1:\n tx *= img_shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n try: # 1-D array-like or int\n ty = np.random.choice(self.width_shift_range)\n ty *= np.random.choice([-1, 1])\n except ValueError: # floating point\n ty = np.random.uniform(-self.width_shift_range,\n self.width_shift_range)\n if np.max(self.width_shift_range) < 1:\n ty *= img_shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(\n -self.shear_range,\n self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(\n self.zoom_range[0],\n self.zoom_range[1],\n 2)\n\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\n\n channel_shift_intensity = None\n if self.channel_shift_range != 0:\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\n self.channel_shift_range)\n\n brightness = None\n if self.brightness_range is not None:\n brightness = np.random.uniform(self.brightness_range[0],\n self.brightness_range[1])\n\n transform_parameters = {'theta': theta,\n 'tx': tx,\n 'ty': ty,\n 'shear': shear,\n 'zx': zx,\n 'zy': zy,\n 'flip_horizontal': flip_horizontal,\n 'flip_vertical': flip_vertical,\n 'channel_shift_intensity': channel_shift_intensity,\n 'brightness': brightness}\n\n return transform_parameters","def mutate_point_rect(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_rect(mutated_genome,index)\n else: #seed == 1:\n shift_point_rect(mutated_genome,index)","def randomize(self):\n #first take care of all parameters (from N(0,1))\n x = self._get_params_transformed()\n x = np.random.randn(x.size)\n self._set_params_transformed(x)\n #now draw from prior where possible\n x = self._get_params()\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\n self._set_params(x)\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)","def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\n def genPos():\n r = radius_scale * self.np_random.rand() + radius_offset\n a = -np.pi * angle_scale + angle_offset\n b = np.pi * angle_scale + angle_offset\n ang = (b - a) * self.np_random.rand() + a\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\n def isNear(pos, poss):\n for p, o in poss:\n if np.linalg.norm(p - pos) < near_distance:\n return True\n return False\n def genPosRetry(poss):\n for i in range(retry):\n pos = genPos()\n if not isNear(pos, poss):\n return pos\n return genPos()\n poss = []\n for i in range(num):\n pos = genPosRetry(poss)\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\n poss.append((pos, orn))\n self.np_random.shuffle(poss)\n return poss","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def random_plane_points(num_points, bounds):\n\n # Infer dimension of data from bounds\n (bounds, dimension) = infer_dimension(bounds)\n\n # Generate points and rescale to fit bounds\n points = np.random.rand(num_points, dimension)\n unit_mean = [0.5] * dimension\n shifted_points = points - unit_mean + bounds.mean(axis=1)\n scale = bounds[:, 1] - bounds[:, 0]\n rescaled_points = np.dot(shifted_points, np.diag(scale))\n\n return rescaled_points","def randTheta(k, scale=1):\n return generatePoints(1, k, scale=scale)[0].reshape((k + 1, -1))","def totem_random():\n random_head()\n random_head()\n random_head()","def random_transform(self, x):\n pass","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def cointoss():\n return random.random() < 0.5","def repick(g1_x, g1_y, g1_z):\n i = random.randint(0, len(g1_x) - 1)\n x = g1_x[i]\n y = g1_y[i]\n z = g1_z[i]\n return x, y, z","def randomizePlayerPose(transform, arena_radius=8):\n initial_r = arena_radius * random.random()\n initial_theta = 2 * math.pi * random.random()\n initial_x = initial_r * math.cos(initial_theta)\n initial_y = initial_r * math.sin(initial_theta)\n initial_rotation = 2 * math.pi * random.random()\n transform.translation.x = initial_x\n transform.translation.y = initial_y\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])","def resample(self):\n self.X = np.random.uniform(-1, 1, (100, 2))\n self.generate_y()\n self.phi = None\n self.K = 0\n self.centers = None\n self.cluster_sizes = None\n self.g = None\n self.gamma = None","def __call__(self, results):\n if np.random.rand() > self.prob:\n return results\n h, w = results['image'].shape[:2]\n center = self.center\n if center is None:\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\n angle = random_negative(self.angle, self.random_negative_prob)\n self._rotate_img(results, angle, center, self.scale)\n return results","def move(self):\n if self._z >= 75:\n a = random.random()\n print(str(a))\n if a < 0.2:\n self._z += 1\n if a > 0.2 and a < 0.9:\n self._z -= 1\n if a > 0.9:\n self._z = self._z\n else: \n self._z -= 1\n \n b = random.random()\n print(str(b))\n if b < 0.1:\n self._y += 1\n if b > 0.1 and b < 0.2:\n self._y -= 1\n if b > 0.2 and b < 0.25:\n self._x -= 1\n if b > 0.25:\n self._x += 1","def random_sample(grid_size):\r\n g = grid_size\r\n x_range = g[1] - g[0]\r\n\r\n y_range = g[3] - g[2]\r\n\r\n x_off = g[0]\r\n y_off = g[2]\r\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \r\n return (x,y)","def generate_random_DC_crack_coupled_tensor():\n # 1. Generate random DC MT and crack MT:\n # generate DC MT:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\n # Get between small range:\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\n random_num = random.random()\n if random_num <= 0.5:\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\n elif random_num > 0.5:\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n # And redistribute evenly everywhere on boundary:\n random_num = random.random()\n if random_num>0.25 and random_num<=0.5:\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\n if random_num>0.5 and random_num<=0.75:\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\n if random_num>0.75 and random_num<=1.0:\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\n # --- ---\n # random_num = random.random()\n # if random_num <= 0.5:\n # theta_lune_sphere = random.random()*np.pi/2.\n # elif random_num > 0.5:\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\n # random_num = random.random()\n # if random_num <= 0.5:\n # phi_lune_sphere = np.pi/6.\n # elif random_num > 0.5:\n # phi_lune_sphere = -1.*np.pi/6.\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\n # 2. Combine DC and crack tensors:\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\n # 3. Randomly rotate DC-crack MT to random orientation:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\n # 4. Normalise and get 6 MT:\n # Get 6 MT:\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\n # And normallise so that moment tensor magnitude = 1:\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\n return DC_crack_six_MT_rotated_normalised, random_amp_frac","def shift_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def get_random_translations(atom_pos, beam_focus_size, jet_radius):\n N = len(atom_pos)\n beam_focus_radius = beam_focus_size/2\n flag = True\n while(flag):\n x_trans = beam_focus_radius*np.random.uniform(-1, 1)\n y_trans = beam_focus_radius*np.random.uniform(-1, 1)\n z_trans = jet_radius*np.random.uniform(-1, 1)\n trans = [[x_trans, y_trans, z_trans]]*N\n trans = np.asarray(trans)\n new_pos = atom_pos + trans\n print (\"trans_new_pos\", new_pos)\n for i in range(N):\n if (np.sqrt(new_pos[i][0]**2 + new_pos[i][1]**2) >= beam_focus_radius):\n flag = False\n break\n else:\n flag = False\n return new_pos","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def aecSpaceRandomTowers():\n origin = aecPoint(0, 0, 0)\n displace = 175\n spacer = aecSpacer()\n shaper = aecShaper()\n \n def full(point, xWidth, yDepth, zHeight, level):\n floor = aecSpace()\n floor.boundary = shaper.makeBox(point, xWidth, yDepth)\n floor.height = zHeight\n floor.level = level\n setColors([floor])\n return [floor]\n \n def halfDepth(point, xWidth, yDepth, zHeight, level):\n depth = yDepth * 0.5\n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, xWidth, depth)\n half1.height = zHeight\n half1.level = level\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\n setColors(halfSpaces)\n return halfSpaces\n \n def halfWidth(point, xWidth, yDepth, zHeight, level):\n width = xWidth * 0.5\n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, width, yDepth)\n half1.height = zHeight\n half1.level = level\n halfSpaces = [half1] + spacer.row(half1)\n setColors(halfSpaces)\n return halfSpaces\n \n def quarterDepth(point, xWidth, yDepth, zHeight, level):\n if randint(0, 1) == 0:\n depth = yDepth * 0.25\n scale = 3\n else:\n depth = yDepth * 0.75\n scale = 0.333333333 \n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, xWidth, depth)\n half1.height = zHeight\n half1.level = level \n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\n halfSpaces[1].scale(1, scale, 1, halfSpaces[1].points_floor[0])\n setColors(halfSpaces)\n return halfSpaces\n \n def quarterWidth(point, xWidth, yDepth, zHeight, level):\n if randint(0, 1) == 0:\n width = xWidth * 0.25\n scale = 3\n else:\n width = xWidth * 0.75\n scale = 0.333333333 \n half1 = aecSpace() \n half1.boundary = shaper.makeBox(point, width, yDepth)\n half1.height = zHeight\n half1.level = level \n halfSpaces = [half1] + spacer.row(half1)\n halfSpaces[1].scale(scale, 1, 1, halfSpaces[1].points_floor[0])\n setColors(halfSpaces)\n return halfSpaces\n \n def setColors(halfSpaces):\n colors = [aecColor.blue, aecColor.orange, aecColor.purple, aecColor.yellow]\n colorPick = randint(0, 3)\n halfSpaces[0].color = colors[colorPick]\n if len(halfSpaces) == 1: return\n colors.reverse()\n halfSpaces[1].color = colors[colorPick]\n \n def makeFloor(point, xWidth, yDepth, zHeight, level):\n floorType = randint(0, 4)\n if floorType == 0: floorSpaces = full(point, xWidth, yDepth, zHeight, level)\n if floorType == 1: floorSpaces = halfDepth(point, xWidth, yDepth, zHeight, level)\n if floorType == 2: floorSpaces = halfWidth(point, xWidth, yDepth, zHeight, level)\n if floorType == 3: floorSpaces = quarterDepth(point, xWidth, yDepth, zHeight, level)\n if floorType == 4: floorSpaces = quarterWidth(point, xWidth, yDepth, zHeight, level)\n return floorSpaces\n \n def makeCore(point, xWidth, yDepth, zHeight): \n xCoord = (point.x - 5) + (xWidth * 0.5)\n yCoord = (point.y + (yDepth * (randint(0, 9) * 0.1)))\n point = aecPoint(xCoord, yCoord, point.z)\n core = aecSpace()\n core.boundary = shaper.makeBox(point, 10, 20)\n core.height = zHeight\n core.color = aecColor.gray\n return [core]\n \n def makeTower(point):\n floors = []\n xWidth = uniform(20, 60)\n yDepth = uniform(20, 60)\n levels = randint(5, 50)\n zHeight = uniform(3, 6)\n plinth = aecSpace()\n plinth.boundary = shaper.makeBox(point, xWidth, yDepth)\n plinthScaleX = (uniform(1, 2.5))\n plinthScaleY = (uniform(1, 2.5))\n plinth.scale(plinthScaleX, plinthScaleY, 2, plinth.centroid_floor)\n plinth.height = (zHeight * 2)\n plinth.color = aecColor.green\n floors.append(plinth)\n floors = floors + makeCore(point, xWidth, yDepth, zHeight * (levels + 3))\n level = (zHeight * 2)\n x = 0\n while x < levels:\n floors = floors + makeFloor(point, xWidth, yDepth, zHeight, level)\n level += zHeight\n x += 1 \n return floors\n \n def makeTowerRow(point, columns, displacement):\n towers = []\n towers = towers + makeTower(point)\n x = 0\n while x < columns:\n point.x += displacement\n towers = towers + makeTower(point)\n x += 1\n return towers\n \n def makeTowerRows(point, displacement, columns, rows):\n towers = []\n x = 0\n while x < rows:\n towers = towers + makeTowerRow(point, columns, displacement)\n point.x = 0\n point.y += displacement\n x += 1\n return towers\n \n return makeTowerRows(origin, displace, 4, 5)","def sample_preimage(self, point, seed=None):\r\n [[a, b], [c, d]] = self.B0_fft\r\n\r\n # We compute a vector t_fft such that:\r\n # (fft(point), fft(0)) * B0_fft = t_fft\r\n # Because fft(0) = 0 and the inverse of B has a very specific form,\r\n # we can do several optimizations.\r\n '''\r\n print(\"---------Inside sample_preimage----------\")\r\n print(\"point: \", point)\r\n '''\r\n\r\n point_fft = fft(point)\r\n\r\n t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]\r\n t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]\r\n t_fft = [t0_fft, t1_fft]\r\n\r\n # We now compute v such that:\r\n # v = z * B0 for an integral vector z\r\n # v is close to (point, 0)\r\n if seed is None:\r\n # If no seed is defined, use urandom as the pseudo-random source.\r\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)\r\n\r\n else:\r\n # If a seed is defined, initialize a ChaCha20 PRG\r\n # that is used to generate pseudo-randomness.\r\n chacha_prng = ChaCha20(seed)\r\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,\r\n chacha_prng.randombytes)\r\n\r\n v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))\r\n v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))\r\n v0 = [int(round(elt)) for elt in ifft(v0_fft)]\r\n v1 = [int(round(elt)) for elt in ifft(v1_fft)]\r\n\r\n # The difference s = (point, 0) - v is such that:\r\n # s is short\r\n # s[0] + s[1] * h = point\r\n s = [sub(point, v0), neg(v1)]\r\n return s","def random():\n np.random.seed(0)","def modify_pt(pt=None,):\n global dim\n mod_rand_pt = []\n\n for i_ in range(dim):\n for j_ in range(i_, dim):\n mod_rand_pt.append(pt[i_] * pt[j_])\n\n mod_rand_pt.append(1.)\n return mod_rand_pt","def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n #rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]]) # rotate along y axis\n shape_pc = batch_data[k,:,0:3]\n shape_normal = batch_data[k,:,3:6]\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\n return rotated_data","def remove_point(mutated_genome,index):\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n del mutated_genome[index][2][point_index]","def move_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\n point = (Xval,Yval)\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n mutated_genome[index][2][point_index] = point","def rand_raster(center, step_size, num_points, random):\n xscan = []\n yscan = []\n \n xcenter = center[0] # first element of center array\n ycenter = center[1] # second element of center array\n \n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\n \n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n \n # Creates two arrays xscan and yscan\n for step, ystep in enumerate(yrange):\n xscan.append(xrange[::(-1)**step])\n yscan.append(np.ones_like(xrange) * ystep)\n \n xscan = np.concatenate(xscan)\n yscan = np.concatenate(yscan)\n \n # Combine the two arrays into a list of vectors\n raster = []\n \n for i in range(0, len(xscan)):\n scan_element = []\n \n scan_element.append(xscan[i])\n scan_element.append(yscan[i])\n raster.append(scan_element)\n \n return raster","def generate(random, lower, upper, count=1):\n if count > 1:\n points = []\n\n for x in range(lower.x, upper.x):\n for y in range(lower.y, upper.y):\n points.append(Point(x, y)) # REFACTOR: Not very efficient\n\n return random.sample(points, count)\n else:\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))","def _sample_using_random(\n self,\n p: float = 0.1,\n ):\n return sa.func.random() < p","def random_transform(self, x, seed=None):\n # x is a single audio, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\n input_length = x.shape[img_row_axis]\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\n if x.shape[img_row_axis] >= input_length:\n x = x[:input_length]\n else:\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\n 'constant', constant_values=(0, np.mean(x)))\n\n if shift:\n hx = np.random.uniform(-self.shift, self.shift)\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\n\n if self.roll_range:\n tx = np.random.uniform(-self.roll_range, self.roll_range)\n if self.roll_range < 1:\n tx *= x.shape[img_row_axis]\n x = np.roll(x, int(tx), axis=(img_row_axis))\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = np.flip(x, axis=img_row_axis)\n\n if (self.noise):\n if np.random.random() < 0.5:\n if self.noise[-1] == 'Uniform':\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\n elif self.noise[-1] == 'Normal':\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\n\n if self.brightness_range is not None:\n x = random_brightness(x, self.brightness_range)\n\n return x","def get_transforms(partition: str, num_points: int = 1024,\n noise_type: str = 'clean', rot_mag: float = 45.0,\n trans_mag: float = 0.5, partial_p_keep: List = None):\n\n partial_p_keep = partial_p_keep if partial_p_keep is not None else [0.7, 0.7]\n\n if noise_type == \"clean\":\n # 1-1 correspondence for each point (resample first before splitting), no noise\n if partition == 'train':\n transforms = [Transforms.Resampler(num_points),\n Transforms.SplitSourceRef(),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetDeterministic(),\n Transforms.FixedResampler(num_points),\n Transforms.SplitSourceRef(),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"jitter\":\n # Points randomly sampled (might not have perfect correspondence), gaussian noise to position\n if partition == 'train':\n transforms = [Transforms.SetJitterFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetJitterFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"crop\":\n # Both source and reference point clouds cropped, plus same noise in \"jitter\"\n if partition == 'train':\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCrop(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCrop(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n\n elif noise_type == \"cropinv\":\n # Both source and reference point clouds cropped, plus same noise in \"jitter\"\n if partition == 'train':\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCropinv(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n transforms = [Transforms.SetCorpFlag(),\n Transforms.SetDeterministic(),\n Transforms.SplitSourceRef(),\n Transforms.Resampler(num_points),\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\n Transforms.RandomCropinv(partial_p_keep),\n Transforms.RandomJitter(),\n Transforms.ShufflePoints()]\n else:\n raise NotImplementedError\n\n return transforms","def randomize(self):\r\n # first take care of all parameters (from N(0,1))\r\n x = self._get_params_transformed()\r\n x = np.random.randn(x.size)\r\n self._set_params_transformed(x)\r\n # now draw from prior where possible\r\n x = self._get_params()\r\n if self.priors is not None:\r\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\r\n self._set_params(x)\r\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\r","def flip(p=0.5):\n return np.random.random() < p","def image_rotate(Xb, batch_size):\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\n delta = 30. * intensity # scale by self.intensity\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\n return Xb","def reset(self):\n newPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\n self.pot = np.asarray(newPerm)","def augmenter(x, y):\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\n # as 3D microscopy acquisitions are usually not axially symmetric\n x, y = random_fliprot(x, y, axis=(1, 2))\n x = random_intensity_change(x)\n return x, y","def unforeseen():\r\n return random.gauss(300., 100.)","def rotate_point_cloud_in_plane(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, -sinval, 0],\n [sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def random():\n np.random.seed(1939)","def randomize(self, amplitude):\n from random import gauss\n # update alignment from projections\n self.getMarkersFromTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\n\n # add random amplitude\n # markers\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\n for (imark, mark) in enumerate(self._Markers):\n if (imark + 1) != irefmark:\n r = mark.get_r()\n for ii in range(0, 3):\n r[ii] = gauss(0, amplitude) + r[ii]\n self._Markers[imark].set_r(r)\n\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\n # translations, rotations, magnifications\n for itilt in range(0, self._ntilt):\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\n if (self._projIndices[itilt] != ireftilt):\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\n\n # update alignment from projections\n self.setMarkersInTiltSeries(self.TiltSeries_)\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\n self.getRotationsFromTiltSeries(self.TiltSeries_)\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)","def sample_from_belief(self):\n if self._use_information_bottleneck:\n posteriors = [torch.distributions.Normal(m, torch.sqrt(s)) for m, s in zip(torch.unbind(self.z_means), torch.unbind(self.z_vars))]\n z = [d.rsample() for d in posteriors]\n self.z = torch.stack(z)\n else:\n self.z = self.z_means","def rndSphere():\n sph = [0,0,0]\n \n sph[2] = random.uniform(-1.0,1.0)\n z2 = math.sqrt(1.0 - sph[2]*sph[2])\n phi = (2. * math.pi) * random.random()\n sph[0] = z2 * math.cos(phi)\n sph[1] = z2 * math.sin(phi)\n \n return sph","def importance_sampling_step(self, positions, analytic):\n \"\"\"With upgrad method for suggetion of new positions.\"\"\"\n \"\"\"Given through the Langevin equation.\n D is the diffusion coefficient equal 0.5, xi is a gaussion random\n variable and delta_t is the time step between 0.001 and 0.01\"\"\"\n\n D = 0.5\n greens_function = 0.0\n\n if analytic == True:\n F_old = self.w.quantum_force(positions)\n else:\n F_old = self.w.quantum_force_numerical(positions)\n\n # r = random.random()*random.choice((-1, 1))\n # r = np.random.normal()\n r = np.zeros(self.num_d)\n for i in range(self.num_d):\n r[i] = random.gauss(0, 1)\n # Pick a random particle and calculate new position\n random_index = random.randrange(len(positions))\n new_positions = np.array(positions)\n\n term1 = D*F_old[random_index, :]*self.delta_t\n term2 = r*np.sqrt(self.delta_t)\n new_random_position = new_positions[random_index, :] + term1 + term2\n new_positions[random_index, :] = new_random_position\n\n # Check if wave function is zero\n test_wavefunction = self.w.wavefunction(new_positions)\n if test_wavefunction**2 <= 1e-14:\n pass\n else:\n prob_ratio = self.w.wavefunction_ratio(positions, new_positions)\n\n if analytic == True:\n F_new = self.w.quantum_force(new_positions)\n else:\n F_new = self.w.quantum_force_numerical(new_positions)\n\n for i in range(self.num_p):\n for j in range(self.num_d):\n term1 = 0.5*((F_old[i, j] + F_new[i, j]) *\n (positions[i, j] - new_positions[i, j]))\n term2 = D*self.delta_t*(F_old[i, j] - F_new[i, j])\n greens_function += term1 + term2\n\n greens_function = np.exp(greens_function)\n\n epsilon = np.random.sample()\n acceptance_ratio = prob_ratio*greens_function\n\n if acceptance_ratio > epsilon:\n positions = new_positions\n self.s.distances_update(positions, random_index)\n self.c += 1.0\n\n else:\n pass\n\n return positions","def Generate_Random( self ):\n print( 'Generating Random coordinates' )\n stands = self.Data.Stand.keys()\n stands.sort()\n for s in stands:\n trees = self.Data.Stand[s].Tree.keys()\n trees.sort()\n for t in trees:\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )","def test_randoms():\n\n # generate two locusts of points\n npts = 200\n epsilon = 0.3\n # #cluster 1\n coords1 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\n coords2 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\n\n # generate orientation vectors for cluster 1\n vectors1 = normalized_vectors(np.random.random((npts, 3)) * 2.0 - 1.0)\n\n # define radial bins\n rbins = np.array([0.0, 0.1, 2.0 * epsilon])\n s = np.zeros((npts, 3))\n\n s[:, 0] = coords2[:, 0] - coords1[:, 0]\n s[:, 1] = coords2[:, 1] - coords1[:, 1]\n s[:, 2] = coords2[:, 2] - coords1[:, 2]\n\n dist_a = s[:, 0] ** 2 + s[:, 1] ** 2 + s[:, 2] ** 2\n\n # define weights appropiate for weighting function\n weights1 = np.ones((npts, 4))\n weights1[:, 1] = vectors1[:, 0]\n weights1[:, 2] = vectors1[:, 1]\n weights1[:, 3] = vectors1[:, 2]\n weights2 = np.ones(npts)\n\n # weighting 1\n # calculate weighted counts\n weighted_counts, counts = positional_marked_npairs_3d(\n coords1,\n coords2,\n rbins,\n period=None,\n weights1=weights1,\n weights2=weights2,\n weight_func_id=1,\n num_threads=1,\n )\n\n msg = (\n \"weighted counts do not match expected result given the weighting function\"\n + \" \"\n + str(np.max(dist_a))\n )\n assert np.isclose(weighted_counts[-1], 0.0 * counts[-1], atol=4000), msg","def generate(self) -> np.ndarray:\n self.sample_r()\n self.sample_z()\n ind: np.ndarray = np.less_equal(self.z_sample, self.r_sample)\n self.r_sample = self.r_sample[ind]\n self.z_sample = self.z_sample[ind]\n return np.sort(np.sqrt(np.subtract(np.square(self.r_sample), np.square(self.z_sample))))"],"string":"[\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def random_rotation(self, img, p = 0.5):\\n if self.decision(p):\\n theta = random.randrange(-15, 15)\\n phi = random.randrange(-15, 15)\\n gamma = random.randrange(-15, 15)\\n it = ImagePerspectiveTransformer(img, shape=(img.shape[0] + abs(gamma), img.shape[1]))\\n roi = it.rotate_along_axis(theta=theta, phi=phi, gamma=gamma)\\n # check if cut is ahve to much dark pixels, more then 20 %\\n non_zeros = np.count_nonzero(roi)\\n non_zeros_procent = non_zeros / roi.size\\n if non_zeros_procent < 0.8:\\n pass\\n else:\\n img = roi\\n return img\",\n \"def rotate_point_cloud(data):\\n rotated_data = np.zeros(data.shape, dtype=np.float32)\\n for k in xrange(data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def rotate_points(self, pointcloud_model, DEGREES = 0, query_points = False, use_rotation_tensor = False, save_rotation_tensor = False):\\n ## https://en.wikipedia.org/wiki/Rotation_matrix\\n if(use_rotation_tensor != True):\\n angle_range = DEGREES\\n x_angle = radians(random.random() * angle_range)\\n y_angle = radians(random.random() * angle_range)\\n z_angle = radians(random.random() * angle_range)\\n\\n rot_x = torch.Tensor([[1,0,0,0],[0, cos(x_angle),-sin(x_angle),0], [0, sin(x_angle), cos(x_angle),0], [0,0,0,1]])\\n rot_y = torch.Tensor([[cos(y_angle),0,sin(y_angle), 0],[0, 1, 0,0], [-sin(y_angle),0,cos(y_angle),0], [0,0,0,1]])\\n rot_z = torch.Tensor([[cos(z_angle), -sin(z_angle),0,0],[sin(z_angle), cos(z_angle),0,0],[0,0,1,0], [0,0,0,1]])\\n rotation_matrix = torch.mm(rot_y, rot_z)\\n rotation_matrix = torch.mm(rot_x,rotation_matrix) \\n\\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n \\n \\n pointcloud_model_rotated = torch.matmul(pointcloud_model, rotation_matrix.to(self.device))\\n self.rotation_matrix = rotation_matrix\\n \\n if(save_rotation_tensor):\\n torch.save(rotation_matrix, 'rotation_matrix.pt') #used for plane prediction, change it at your will \\n return pointcloud_model_rotated[:,:,0:3], (x_angle, y_angle, z_angle)\\n else: \\n batch_size, point_cloud_size, _ = pointcloud_model.shape\\n pointcloud_model = pointcloud_model / sqrt(0.55**2 + 0.55**2 + 0.55**2)\\n pointcloud_model = torch.cat([pointcloud_model, torch.ones(batch_size, point_cloud_size,1).to(self.device)], dim = 2)\\n pointcloud_model_rotated =torch.matmul(pointcloud_model, self.rotation_matrix.to(self.device))\\n return pointcloud_model_rotated[:,:,0:3]\",\n \"def augment_cloud(Ps):\\n \\\"Augmented params:\\\"\\n pc_augm_scale=0\\n pc_augm_rot=1\\n pc_augm_mirror_prob=0.5\\n pc_augm_jitter=0\\n\\n M = transforms3d.zooms.zfdir2mat(1)\\n if pc_augm_scale > 1:\\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\\n if pc_augm_rot:\\n angle = random.uniform(0, 2*math.pi)\\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\\n result = []\\n for P in Ps:\\n P[:,:3] = np.dot(P[:,:3], M.T)\\n\\n if pc_augm_jitter:\\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\\n result.append(P)\\n return result\",\n \"def randomPointOnSphere(r):\\n x = np.random.normal()\\n y = np.random.normal()\\n z = np.random.normal()\\n point = np.array([x, y, z])\\n point *= r/(x**2 + y**2 + z**2)**.5\\n return point\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def randomize_trajectory(self):\\n self.angle = randint(-360, 360)\\n self.speed = randint(1, 5)/2.5\",\n \"def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)\\n Rx = np.array([[1,0,0],\\n [0,np.cos(angles[0]),-np.sin(angles[0])],\\n [0,np.sin(angles[0]),np.cos(angles[0])]])\\n Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],\\n [0,1,0],\\n [-np.sin(angles[1]),0,np.cos(angles[1])]])\\n Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],\\n [np.sin(angles[2]),np.cos(angles[2]),0],\\n [0,0,1]])\\n R = np.dot(Rz, np.dot(Ry,Rx))\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def resample_particles(self):\\n # make sure the distribution is normalized\\n self.normalize_particles()\\n\\n newParticles = []\\n for i in range(len(self.particle_cloud)):\\n # resample the same # of particles\\n choice = random_sample()\\n # all the particle weights sum to 1\\n csum = 0 # cumulative sum\\n for particle in self.particle_cloud:\\n csum += particle.w\\n if csum >= choice:\\n # if the random choice fell within the particle's weight\\n newParticles.append(deepcopy(particle))\\n break\\n self.particle_cloud = newParticles\",\n \"def _sample_k_new(self, cur_y, cur_z):\\n N = float(len(self.obs))\\n #old_loglik = self._loglik(cur_y, cur_z)\\n\\n k_new_count = np.random.poisson(self.alpha / N)\\n if k_new_count == 0: return False\\n \\n # modify the feature ownership matrix\\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\\n # propose feature images by sampling from the prior distribution\\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\\n \\n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def reroll(self):\\n self._base_x = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._x_min,\\n self.base_point_distribution._x_max\\n )\\n self._base_y = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._y_min,\\n self.base_point_distribution._y_max\\n )\",\n \"def mutate(self, size):\\n rand = random.random()\\n if rand <= 0.5:\\n print u\\\"changing colour\\\"\\n idx = random.randrange(0, 4)\\n value = random.randrange(0, 256)\\n colour = list(self.colour)\\n colour[idx] = value\\n self.colour = tuple(colour)\\n else:\\n print u\\\"changing point\\\"\\n idx = random.randrange(0, len(self.points))\\n point = generate_point(size[0], size[1])\\n self.points[idx] = point\",\n \"def mutate_point_poly3(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def random_rotate(self):\\r\\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\\r\\n flip = rand.randrange(0, 2, 1) # 0, 1\\r\\n new_seed = copy.deepcopy(self)\\r\\n # rotate by 90 degrees * rotation (0, 90, 180 270)\\r\\n new_seed.cells = np.rot90(new_seed.cells, rotation) \\r\\n if (flip == 1):\\r\\n # flip upside down\\r\\n new_seed.cells = np.flipud(new_seed.cells)\\r\\n new_seed.xspan = new_seed.cells.shape[0]\\r\\n new_seed.yspan = new_seed.cells.shape[1]\\r\\n return new_seed\",\n \"def spread_quaternions(points,num=100,quats_per_step=100):\\n quats = np.zeros((num,4))\\n rot_points = np.zeros((num,points.shape[0],3))\\n quats[0,:] = [0,0,0,1]\\n rot_points[0,:,:] = points\\n for ix in range(1,num):\\n rand_quats = random_quaternions(quats_per_step) \\n positioned = rotate_points(points,rand_quats) \\n dists = point_dists(rot_points[:ix],positioned)\\n new_rot = np.argmax(dists) \\n quats[ix,:]=rand_quats[new_rot,:]\\n rot_points[ix,:,:] = positioned[new_rot,:,:]\\n \\n return quats,rot_points\",\n \"def _sample_lam(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_lam = self.lam\\n \\n # modify the feature ownership matrix\\n self.lam = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.lam = old_lam\",\n \"def initialise_particle_cloud(self, initialpose):\\n # ----- Initialize the particle cloud as an empty array\\n self.particlecloud = PoseArray()\\n\\n \\\"\\\"\\\"Create the noise to multiply by the random Gaussian number that will\\n get added to each of the Poses, that are set to a random position\\n and orientation around the initial pose\\\"\\\"\\\"\\n sensorSigma=3 #variance\\n sensorMu=0 #mean\\n noise=sensorSigma * numpy.random.randn() + sensorMu\\n\\n \\\"\\\"\\\"Create a range for the ammount of random Gaussian values to generate \\\"\\\"\\\"\\n randomGauss = 10*self.NUMBER_PREDICTED_READINGS\\n\\n gaussianRandomNumX = []\\n gaussianRandomNumY = []\\n randomYawArray = []\\n\\n for i in range (0,randomGauss):\\n gaussianRandomNumX.append(random.gauss(0,1))\\n gaussianRandomNumY.append(random.gauss(0,1))\\n x=random.randint(1,180)\\n randomYaw=(math.pi/x)\\n randomYawArray.append(randomYaw)\\n\\n iterator = 0\\n\\n \\\"\\\"\\\"\\n\\t Set the particles to a random position and orientation around the initial pose\\n \\\"\\\"\\\"\\n particleNumber = 10**2 # 10**3 # 10**4 # 10**5 experiment with different ammounts of particles\\n\\n while iterator < particleNumber:\\n particle = Pose()\\n particle.position.x = initialpose.pose.pose.position.x + (gaussianRandomNumX[iterator] * noise)\\n particle.position.y = initialpose.pose.pose.position.y + (gaussianRandomNumY[iterator] * noise)\\n particle.position.z = initialpose.pose.pose.position.z\\n particle.orientation = rotateQuaternion(initialpose.pose.pose.orientation, randomYawArray[iterator])\\n\\n self.particlecloud.poses.append(particle)\\n iterator += 1\\n\\n return self.particlecloud\",\n \"def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\\n for sampling_result, img_meta in zip(sampling_results, img_metas):\\n bboxes = sampling_result.pos_bboxes\\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\\n -amplitude, amplitude)\\n # before jittering\\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\\n # after jittering\\n new_cxcy = cxcy + wh * random_offsets[:, :2]\\n new_wh = wh * (1 + random_offsets[:, 2:])\\n # xywh to xyxy\\n new_x1y1 = (new_cxcy - new_wh / 2)\\n new_x2y2 = (new_cxcy + new_wh / 2)\\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\\n # clip bboxes\\n max_shape = img_meta['img_shape']\\n if max_shape is not None:\\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\\n\\n sampling_result.pos_bboxes = new_bboxes\\n return sampling_results\",\n \"def uniform_random(self) -> None:\\n\\n size = self.circ_size\\n random.seed(self.seed)\\n\\n gates = [self.h, self.x, self.y, self.z, self.s, self.t, self.cx]\\n candidates = set(range(size))\\n\\n for i in range(size):\\n for j in range(size):\\n to_apply = random.choice(gates)\\n\\n num_qubits = 2 if to_apply == self.cx else 1\\n targets = random.sample(candidates, num_qubits)\\n to_apply(*targets)\\n\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def mutate_point_circ(mutated_genome):\\n seed = random.randint(0,3)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_circ(mutated_genome,index)\\n elif seed == 1:\\n shift_point_circ(mutated_genome,index)\\n elif seed == 2:\\n move_radius_circ(mutated_genome,index)\\n else: #seed == 3:\\n shift_radius_circ(mutated_genome,index)\",\n \"def getRandomCentroids(data_points, k):\\n return random.sample(data_points, k)\",\n \"def generate_random_surface_points() -> List[SurfacePoint]:\\n surface_points: List[SurfacePoint] = []\\n for _ in range(42):\\n surface_point = SurfacePoint(\\n idx=uuid.uuid4().hex,\\n x=_gen_random_number(),\\n y=_gen_random_number(),\\n z=_gen_random_number(),\\n x_uc_dist=DistUcEnum.uniform,\\n x_uc=_gen_random_number(),\\n y_uc_dist=DistUcEnum.uniform,\\n y_uc=_gen_random_number(),\\n z_uc_dist=DistUcEnum.uniform,\\n z_uc=_gen_random_number(),\\n smooth=0.01,\\n formation=\\\"Formation_0\\\",\\n )\\n surface_points.append(surface_point)\\n return surface_points\",\n \"def generate_base_points(num_points, domain_size, density_map=None,\\n reflect=True):\\n\\n def _try_points(num_points, prob):\\n prob = np.atleast_3d(prob)\\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\\n base_pts = []\\n N = 0\\n while N < num_points:\\n pt = np.random.rand(3) # Generate a point\\n # Test whether to keep it or not\\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\\n if np.random.rand(1) <= prob[indx][indy][indz]:\\n base_pts.append(pt)\\n N += 1\\n base_pts = np.array(base_pts)\\n return base_pts\\n\\n if len(domain_size) == 1: # Spherical\\n domain_size = np.array(domain_size)\\n r = domain_size[0]\\n if density_map is None:\\n # Make an image of a sphere filled with ones and use _try_points\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, 20] = 0\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to spherical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\\n # Reflect base points across perimeter\\n if reflect:\\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_spherical(r, theta, phi)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 2: # Cylindrical or Disk\\n domain_size = np.array(domain_size)\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, :] = 0\\n if domain_size[1] == 0: # Disk\\n density_map = density_map[:, :, 0]\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to cylindrical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n z = Z*domain_size[1]\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n inds = ~((z > domain_size[1]) + (z < 0))\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n if reflect:\\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_cylindrical(r, theta, z)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 3: # Cube or square\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n if domain_size[2] == 0:\\n density_map = density_map[:, :, 0]\\n base_pts = _try_points(num_points, density_map)\\n base_pts = base_pts*domain_size\\n if reflect:\\n base_pts = reflect_base_points(base_pts, domain_size)\\n\\n return base_pts\",\n \"def realize(self):\\n if numpy.random.rand() > self._P:\\n self._w *= 0.0\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def point_sample(img_meta,\\n img_features,\\n points,\\n proj_mat,\\n coord_type,\\n img_scale_factor,\\n img_crop_offset,\\n img_flip,\\n img_pad_shape,\\n img_shape,\\n aligned=True,\\n padding_mode='zeros',\\n align_corners=True):\\n\\n # apply transformation based on info in img_meta\\n points = apply_3d_transformation(\\n points, coord_type, img_meta, reverse=True)\\n\\n # project points to camera coordinate\\n pts_2d = points_cam2img(points, proj_mat)\\n\\n # img transformation: scale -> crop -> flip\\n # the image is resized by img_scale_factor\\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\\n img_coors -= img_crop_offset\\n\\n # grid sample, the valid grid range should be in [-1,1]\\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\\n\\n if img_flip:\\n # by default we take it as horizontal flip\\n # use img_shape before padding for flip\\n orig_h, orig_w = img_shape\\n coor_x = orig_w - coor_x\\n\\n h, w = img_pad_shape\\n coor_y = coor_y / h * 2 - 1\\n coor_x = coor_x / w * 2 - 1\\n grid = torch.cat([coor_x, coor_y],\\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\\n\\n # align_corner=True provides higher performance\\n mode = 'bilinear' if aligned else 'nearest'\\n point_features = F.grid_sample(\\n img_features,\\n grid,\\n mode=mode,\\n padding_mode=padding_mode,\\n align_corners=align_corners) # 1xCx1xN feats\\n\\n return point_features.squeeze().t()\",\n \"def generate_random_point(det):\\n xmin, ymin, zmin = det.ActiveVolume().Min()\\n xmax, ymax, zmax = det.ActiveVolume().Max()\\n return geoalgo.Vector(np.random.random() * (xmax - xmin) + xmin,\\n np.random.random() * (ymax - ymin) + ymin,\\n np.random.random() * (zmax - zmin) + zmin)\",\n \"def _generate_pores(self):\\n logger.info(\\\"Place randomly located pores in the domain\\\")\\n #Original Random Point Generator\\n #coords = sp.rand(self._Np,3)*[self._Lx,self._Ly,self._Lz]\\n #Seeding Code\\n coords = np.zeros([self._Np,3])\\n #reject points close to boundaries - if False there will be slightly more\\n rejection = [False,False,True]\\n for j in range(3):\\n i = 0\\n while i < self._Np:\\n coord = np.random.uniform(0,1,1)\\n if self._reject(coord) == rejection[j]:\\n coords[i][j]=coord\\n i += 1\\n coords*=np.array([self._Lx,self._Ly,self._Lz])\\n #Seeding Code\\n #Uniform Random Generator\\n #coords = np.array([np.random.uniform(0,self._Lx,self._Np),np.random.uniform(0,self._Ly,self._Np),np.random.uniform(0,self._Lz,self._Np)]).T\\n\\n self['pore.coords'] = coords\\n logger.debug(\\\"End of method\\\")\",\n \"def mutate_point_trig(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_trig(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_trig(mutated_genome,index)\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def pepper(self, prob=0.08):\\n h, w, c = self.img.shape\\n for i in range(h):\\n for j in range(w):\\n if random() < prob:\\n self.img[i, j] = 0\\n\\n self.edits.append(f\\\"pepper:{prob}\\\")\\n return self\",\n \"def prep_pointcloud(input_dict,\\n root_path,\\n voxel_generator,\\n target_assigner,\\n db_sampler=None,\\n max_voxels=20000,\\n max_sweeps=10,\\n remove_outside_points=False,\\n training=True,\\n create_targets=True,\\n shuffle_points=False,\\n remove_unknown=False,\\n gt_rotation_noise=(-np.pi / 3, np.pi / 3),\\n gt_loc_noise_std=(1.0, 1.0, 1.0),\\n global_rotation_noise=(-np.pi / 4, np.pi / 4),\\n global_scaling_noise=(0.95, 1.05),\\n global_random_rot_range=(0.78, 2.35),\\n global_translate_noise_std=(0, 0, 0),\\n num_point_features=4,\\n anchor_area_threshold=1,\\n gt_points_drop=0.0,\\n gt_drop_max_keep=10,\\n remove_points_after_sample=True,\\n anchor_cache=None,\\n remove_environment=False,\\n random_crop=False,\\n reference_detections=None,\\n out_size_factor=2,\\n use_group_id=False,\\n multi_gpu=False,\\n min_points_in_gt=-1,\\n random_flip_x=True,\\n random_flip_y=True,\\n sample_importance=1.0,\\n out_dtype=np.float32):\\n t = time.time()\\n class_names = target_assigner.classes\\n points = input_dict[\\\"lidar\\\"][\\\"points\\\"]\\n indices = input_dict[\\\"lidar\\\"][\\\"indices\\\"]\\n origins = input_dict[\\\"lidar\\\"][\\\"origins\\\"]\\n if training:\\n anno_dict = input_dict[\\\"lidar\\\"][\\\"annotations\\\"]\\n gt_dict = {\\n \\\"gt_boxes\\\": anno_dict[\\\"boxes\\\"],\\n \\\"gt_names\\\": anno_dict[\\\"names\\\"],\\n \\\"gt_importance\\\": np.ones([anno_dict[\\\"boxes\\\"].shape[0]], dtype=anno_dict[\\\"boxes\\\"].dtype),\\n }\\n if \\\"difficulty\\\" not in anno_dict:\\n difficulty = np.zeros([anno_dict[\\\"boxes\\\"].shape[0]],\\n dtype=np.int32)\\n gt_dict[\\\"difficulty\\\"] = difficulty\\n else:\\n gt_dict[\\\"difficulty\\\"] = anno_dict[\\\"difficulty\\\"]\\n if use_group_id and \\\"group_ids\\\" in anno_dict:\\n group_ids = anno_dict[\\\"group_ids\\\"]\\n gt_dict[\\\"group_ids\\\"] = group_ids\\n calib = None\\n if \\\"calib\\\" in input_dict:\\n calib = input_dict[\\\"calib\\\"]\\n\\n # # Disable these two since we do not do this for NuScenes\\n # if reference_detections is not None:\\n # assert calib is not None and \\\"image\\\" in input_dict\\n # C, R, T = box_np_ops.projection_matrix_to_CRT_kitti(P2)\\n # frustums = box_np_ops.get_frustum_v2(reference_detections, C)\\n # frustums -= T\\n # frustums = np.einsum('ij, akj->aki', np.linalg.inv(R), frustums)\\n # frustums = box_np_ops.camera_to_lidar(frustums, rect, Trv2c)\\n # surfaces = box_np_ops.corner_to_surfaces_3d_jit(frustums)\\n # masks = points_in_convex_polygon_3d_jit(points, surfaces)\\n # points = points[masks.any(-1)]\\n # if remove_outside_points:\\n # assert calib is not None\\n # image_shape = input_dict[\\\"image\\\"][\\\"image_shape\\\"]\\n # points = box_np_ops.remove_outside_points(\\n # points, calib[\\\"rect\\\"], calib[\\\"Trv2c\\\"], calib[\\\"P2\\\"], image_shape)\\n\\n # # Very interesting attempt\\n # # I have tried the same and found it doesn't really work\\n # if remove_environment is True and training:\\n # selected = kitti.keep_arrays_by_name(gt_names, target_assigner.classes)\\n # _dict_select(gt_dict, selected)\\n # masks = box_np_ops.points_in_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n # points = points[masks.any(-1)]\\n\\n metrics = {}\\n\\n point_indices_to_remove = None\\n if training:\\n \\\"\\\"\\\"\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n bev_map = simplevis.nuscene_vis(points, boxes_lidar)\\n cv2.imshow('pre-noise', bev_map)\\n \\\"\\\"\\\"\\n selected = kitti.drop_arrays_by_name(gt_dict[\\\"gt_names\\\"], [\\\"Denture\\\"])\\n _dict_select(gt_dict, selected)\\n if remove_unknown:\\n remove_mask = gt_dict[\\\"difficulty\\\"] == -1\\n \\\"\\\"\\\"\\n gt_boxes_remove = gt_boxes[remove_mask]\\n gt_boxes_remove[:, 3:6] += 0.25\\n points = prep.remove_points_in_boxes(points, gt_boxes_remove)\\n \\\"\\\"\\\"\\n keep_mask = np.logical_not(remove_mask)\\n _dict_select(gt_dict, keep_mask)\\n gt_dict.pop(\\\"difficulty\\\")\\n\\n # This part is interesting - we will need to do the same\\n if min_points_in_gt > 0:\\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n mask = point_counts >= min_points_in_gt\\n _dict_select(gt_dict, mask)\\n\\n gt_boxes_mask = np.array(\\n [n in class_names for n in gt_dict[\\\"gt_names\\\"]], dtype=np.bool_)\\n\\n if db_sampler is not None:\\n group_ids = None\\n if \\\"group_ids\\\" in gt_dict:\\n group_ids = gt_dict[\\\"group_ids\\\"]\\n\\n sampled_dict = db_sampler.sample_all(\\n root_path,\\n gt_dict[\\\"gt_boxes\\\"],\\n gt_dict[\\\"gt_names\\\"],\\n num_point_features,\\n random_crop,\\n gt_group_ids=group_ids,\\n calib=calib)\\n\\n if sampled_dict is not None:\\n sampled_gt_names = sampled_dict[\\\"gt_names\\\"]\\n sampled_gt_boxes = sampled_dict[\\\"gt_boxes\\\"]\\n sampled_points = sampled_dict[\\\"points\\\"]\\n sampled_gt_masks = sampled_dict[\\\"gt_masks\\\"]\\n gt_dict[\\\"gt_names\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_names\\\"], sampled_gt_names], axis=0)\\n gt_dict[\\\"gt_boxes\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_boxes\\\"], sampled_gt_boxes])\\n gt_boxes_mask = np.concatenate(\\n [gt_boxes_mask, sampled_gt_masks], axis=0)\\n sampled_gt_importance = np.full(\\n [sampled_gt_boxes.shape[0]], sample_importance,\\n dtype=sampled_gt_boxes.dtype)\\n gt_dict[\\\"gt_importance\\\"] = np.concatenate(\\n [gt_dict[\\\"gt_importance\\\"], sampled_gt_importance])\\n\\n if group_ids is not None:\\n sampled_group_ids = sampled_dict[\\\"group_ids\\\"]\\n gt_dict[\\\"group_ids\\\"] = np.concatenate(\\n [gt_dict[\\\"group_ids\\\"], sampled_group_ids])\\n\\n # # Commented out because we have a new way of removing points\\n # if remove_points_after_sample:\\n # masks = box_np_ops.points_in_rbbox(points, sampled_gt_boxes)\\n # point_indices_to_remove = np.flatnonzero(masks.any(-1))\\n # # # Delay this process so we can use the full point cloud\\n # # # when we do the ray stopping algorithm\\n # # points = points[np.logical_not(masks.any(-1))]\\n\\n # # Paste objects behind so that we don't have to update indices\\n # points = np.concatenate([sampled_points, points], axis=0)\\n points = np.concatenate([points, sampled_points], axis=0)\\n\\n pc_range = voxel_generator.point_cloud_range\\n group_ids = None\\n if \\\"group_ids\\\" in gt_dict:\\n group_ids = gt_dict[\\\"group_ids\\\"]\\n\\n # # Disable this one for now (not used in PointPillars anyways)\\n # prep.noise_per_object_v3_(\\n # gt_dict[\\\"gt_boxes\\\"],\\n # points,\\n # gt_boxes_mask,\\n # rotation_perturb=gt_rotation_noise,\\n # center_noise_std=gt_loc_noise_std,\\n # global_random_rot_range=global_random_rot_range,\\n # group_ids=group_ids,\\n # num_try=100)\\n\\n # should remove unrelated objects after noise per object\\n # for k, v in gt_dict.items():\\n # print(k, v.shape)\\n _dict_select(gt_dict, gt_boxes_mask)\\n gt_classes = np.array(\\n [class_names.index(n) + 1 for n in gt_dict[\\\"gt_names\\\"]],\\n dtype=np.int32)\\n gt_dict[\\\"gt_classes\\\"] = gt_classes\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.random_flip(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, 0.5, random_flip_x, random_flip_y)\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.global_rotation_v2(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, *global_rotation_noise)\\n gt_dict[\\\"gt_boxes\\\"], points, origins = prep.global_scaling_v2(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, *global_scaling_noise)\\n prep.global_translate_(\\n gt_dict[\\\"gt_boxes\\\"], points, origins, global_translate_noise_std)\\n bv_range = voxel_generator.point_cloud_range[[0, 1, 3, 4]]\\n mask = prep.filter_gt_box_outside_range_by_center(gt_dict[\\\"gt_boxes\\\"], bv_range)\\n _dict_select(gt_dict, mask)\\n\\n # limit rad to [-pi, pi]\\n gt_dict[\\\"gt_boxes\\\"][:, 6] = box_np_ops.limit_period(\\n gt_dict[\\\"gt_boxes\\\"][:, 6], offset=0.5, period=2 * np.pi)\\n\\n # boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n # bev_map = simplevis.nuscene_vis(points, boxes_lidar)\\n # cv2.imshow('post-noise', bev_map)\\n # cv2.waitKey(0)\\n\\n # # Disable this for now (not used in PointPillars anyways)\\n # if shuffle_points:\\n # # shuffle is a little slow.\\n # np.random.shuffle(points)\\n\\n # [0, -40, -3, 70.4, 40, 1]\\n voxel_size = voxel_generator.voxel_size\\n pc_range = voxel_generator.point_cloud_range\\n grid_size = voxel_generator.grid_size\\n\\n # organize points into lists based on timestamps\\n time_stamps = points[indices[:-1], -1] # counting on the fact we do not miss points from any intermediate time_stamps\\n time_stamps = (time_stamps[:-1]+time_stamps[1:])/2\\n time_stamps = [-1000.0] + time_stamps.tolist() + [1000.0] # add boundaries\\n time_stamps = np.array(time_stamps)\\n\\n # # LL_OCCUPIED, LL_FREE = 0.85, -0.4\\n # lo_occupied = np.log(0.7 / (1 - 0.7))\\n # lo_free = np.log(0.4 / (1 - 0.4))\\n\\n # is there are additional points (from database sampling)\\n num_original = indices[-1]\\n if len(points) > num_original:\\n # split data into two half (indexed and un-indexed)\\n original_points, sampled_points = points[:num_original], points[num_original:]\\n # compute occupancy and masks\\n # visibility, original_mask, sampled_mask = mapping.compute_visibility_and_masks(\\n # original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size)\\n # )\\n logodds, original_mask, sampled_mask = mapping.compute_logodds_and_masks(\\n original_points, sampled_points, origins, time_stamps, pc_range, min(voxel_size) # , lo_occupied, lo_free\\n )\\n # apply visible mask\\n points = np.concatenate((original_points[original_mask], sampled_points[sampled_mask]))\\n else:\\n # visibility = mapping.compute_visibility(\\n # points, origins, time_stamps, pc_range, min(voxel_size)\\n # )\\n logodds = mapping.compute_logodds(\\n points, origins, time_stamps, pc_range, min(voxel_size) #, lo_occupied, lo_free\\n )\\n\\n # T = len(time_stamps)-1\\n # visibility = visibility.reshape(T, -1)\\n # if T < (1 + max_sweeps):\\n # visibility = np.pad(visibility, ((0, (1+max_sweeps)-T), (0,0)), 'edge')\\n\\n # with open(f'./utils/mapping/examples/{time.time()}.pkl', 'wb') as f:\\n # ##\\n # pickle.dump(original_points, f)\\n # pickle.dump(sampled_points, f)\\n # pickle.dump(origins, f)\\n # pickle.dump(time_stamps, f)\\n # pickle.dump(pc_range, f)\\n # pickle.dump(voxel_size, f)\\n # ##\\n # pickle.dump(occupancy, f)\\n # pickle.dump(original_mask, f)\\n # pickle.dump(sampled_mask, f)\\n\\n if training:\\n if min_points_in_gt > 0:\\n # points_count_rbbox takes 10ms with 10 sweeps nuscenes data\\n point_counts = box_np_ops.points_count_rbbox(points, gt_dict[\\\"gt_boxes\\\"])\\n mask = point_counts >= min_points_in_gt\\n _dict_select(gt_dict, mask)\\n\\n # [352, 400]\\n t1 = time.time()\\n if not multi_gpu:\\n res = voxel_generator.generate(\\n points, max_voxels)\\n voxels = res[\\\"voxels\\\"]\\n coordinates = res[\\\"coordinates\\\"]\\n num_points = res[\\\"num_points_per_voxel\\\"]\\n num_voxels = np.array([voxels.shape[0]], dtype=np.int64)\\n else:\\n res = voxel_generator.generate_multi_gpu(\\n points, max_voxels)\\n voxels = res[\\\"voxels\\\"]\\n coordinates = res[\\\"coordinates\\\"]\\n num_points = res[\\\"num_points_per_voxel\\\"]\\n num_voxels = np.array([res[\\\"voxel_num\\\"]], dtype=np.int64)\\n metrics[\\\"voxel_gene_time\\\"] = time.time() - t1\\n example = {\\n 'voxels': voxels,\\n # 'visibility': visibility,\\n 'logodds': logodds, \\n 'num_points': num_points,\\n 'coordinates': coordinates,\\n \\\"num_voxels\\\": num_voxels,\\n \\\"metrics\\\": metrics,\\n }\\n if calib is not None:\\n example[\\\"calib\\\"] = calib\\n feature_map_size = grid_size[:2] // out_size_factor\\n feature_map_size = [*feature_map_size, 1][::-1]\\n # print(f'feature_map_size in prep_pointcloud(): {feature_map_size}')\\n if anchor_cache is not None:\\n # print('having anchor cache')\\n anchors = anchor_cache[\\\"anchors\\\"]\\n anchors_bv = anchor_cache[\\\"anchors_bv\\\"]\\n anchors_dict = anchor_cache[\\\"anchors_dict\\\"]\\n matched_thresholds = anchor_cache[\\\"matched_thresholds\\\"]\\n unmatched_thresholds = anchor_cache[\\\"unmatched_thresholds\\\"]\\n\\n else:\\n # print('NOT having anchor cache')\\n ret = target_assigner.generate_anchors(feature_map_size)\\n anchors = ret[\\\"anchors\\\"]\\n anchors = anchors.reshape([-1, target_assigner.box_ndim])\\n anchors_dict = target_assigner.generate_anchors_dict(feature_map_size)\\n anchors_bv = box_np_ops.rbbox2d_to_near_bbox(\\n anchors[:, [0, 1, 3, 4, 6]])\\n matched_thresholds = ret[\\\"matched_thresholds\\\"]\\n unmatched_thresholds = ret[\\\"unmatched_thresholds\\\"]\\n # print(f'anchors.shape: {anchors.shape}')\\n\\n example[\\\"anchors\\\"] = anchors\\n anchors_mask = None\\n if anchor_area_threshold >= 0:\\n # slow with high resolution. recommend disable this forever.\\n coors = coordinates\\n dense_voxel_map = box_np_ops.sparse_sum_for_anchors_mask(\\n coors, tuple(grid_size[::-1][1:]))\\n dense_voxel_map = dense_voxel_map.cumsum(0)\\n dense_voxel_map = dense_voxel_map.cumsum(1)\\n anchors_area = box_np_ops.fused_get_anchors_area(\\n dense_voxel_map, anchors_bv, voxel_size, pc_range, grid_size)\\n anchors_mask = anchors_area > anchor_area_threshold\\n # example['anchors_mask'] = anchors_mask.astype(np.uint8)\\n example['anchors_mask'] = anchors_mask\\n # print(\\\"prep time\\\", time.time() - t)\\n metrics[\\\"prep_time\\\"] = time.time() - t\\n if not training:\\n return example\\n example[\\\"gt_names\\\"] = gt_dict[\\\"gt_names\\\"]\\n # voxel_labels = box_np_ops.assign_label_to_voxel(gt_boxes, coordinates,\\n # voxel_size, coors_range)\\n if create_targets:\\n t1 = time.time()\\n targets_dict = target_assigner.assign(\\n anchors,\\n anchors_dict,\\n gt_dict[\\\"gt_boxes\\\"],\\n anchors_mask,\\n gt_classes=gt_dict[\\\"gt_classes\\\"],\\n gt_names=gt_dict[\\\"gt_names\\\"],\\n matched_thresholds=matched_thresholds,\\n unmatched_thresholds=unmatched_thresholds,\\n importance=gt_dict[\\\"gt_importance\\\"])\\n\\n \\\"\\\"\\\"\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n bev_map = simplevis.nuscene_vis(points, boxes_lidar, gt_dict[\\\"gt_names\\\"])\\n assigned_anchors = anchors[targets_dict['labels'] > 0]\\n ignored_anchors = anchors[targets_dict['labels'] == -1]\\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], ignored_anchors, [128, 128, 128], 2)\\n bev_map = simplevis.draw_box_in_bev(bev_map, [-50, -50, 3, 50, 50, 1], assigned_anchors, [255, 0, 0])\\n cv2.imshow('anchors', bev_map)\\n cv2.waitKey(0)\\n\\n boxes_lidar = gt_dict[\\\"gt_boxes\\\"]\\n pp_map = np.zeros(grid_size[:2], dtype=np.float32)\\n voxels_max = np.max(voxels[:, :, 2], axis=1, keepdims=False)\\n voxels_min = np.min(voxels[:, :, 2], axis=1, keepdims=False)\\n voxels_height = voxels_max - voxels_min\\n voxels_height = np.minimum(voxels_height, 4)\\n # sns.distplot(voxels_height)\\n # plt.show()\\n pp_map[coordinates[:, 1], coordinates[:, 2]] = voxels_height / 4\\n pp_map = (pp_map * 255).astype(np.uint8)\\n pp_map = cv2.cvtColor(pp_map, cv2.COLOR_GRAY2RGB)\\n pp_map = simplevis.draw_box_in_bev(pp_map, [-50, -50, 3, 50, 50, 1], boxes_lidar, [128, 0, 128], 1)\\n cv2.imshow('heights', pp_map)\\n cv2.waitKey(0)\\n \\\"\\\"\\\"\\n example.update({\\n 'labels': targets_dict['labels'],\\n 'reg_targets': targets_dict['bbox_targets'],\\n # 'reg_weights': targets_dict['bbox_outside_weights'],\\n 'importance': targets_dict['importance'],\\n })\\n return example\",\n \"def randomize(self):\\n\\t\\tif self.hasRandomizedAmplitudes:\\n\\t\\t\\tself.unrandomize()\\n\\t\\tself.randoms = np.random.multivariate_normal(np.zeros((2*self.totalBins)), self.coma)\\n\\t\\tfor i in range(self.totalBins):\\n\\t\\t\\tself.reals[i] += self.randoms[2*i ]\\n\\t\\t\\tself.imags[i] += self.randoms[2*i+1]\\n\\t\\tself.hasRandomizedAmplitudes = True\",\n \"def reset(self):\\n self.x = random.uniform(-0.05, 0.05)\\n self.x_dot = random.uniform(-0.05, 0.05)\\n self.theta = random.uniform(-0.05, 0.05)\\n self.theta_dot = random.uniform(-0.05, 0.05)\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def elapseTime(self, gameState):\\n newParticleList = []\\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\\n # likely the ghost is to move to that position\\n for particle in self.particles:\\n newPosDist = self.getPositionDistribution(gameState, particle)\\n newParticleList.append(util.sample(newPosDist))\\n self.particles = newParticleList\",\n \"def mutate_point_poly(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 3: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def JitterPoints(points, sigma=0.01): \\n C = 3\\n assert(points.shape[1] == C)\\n\\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\\n return points + randJitters\",\n \"def MovePoint(pos,points,s=0.5, k = 1000): \\n \\n x = [pos[0]] \\n y = [pos[1]]\\n rdm.seed(1) # comment out if you want randomness\\n for i in range(k):\\n n = len(points)\\n r = int(rdm.random()*n)\\n \\n x.append(x[i] + (points[r][0] - x[i]) * s)\\n y.append(y[i] + (points[r][1] - y[i]) * s)\\n\\n \\n return(x,y)\",\n \"def test_rotating_phantom(self):\\n cheese = TomoCheese.from_demo_images()\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -0.25, abs_tol=0.05)\\n for img in cheese.dicom_stack:\\n img.array = rotate(img.array, angle=3, mode=\\\"edge\\\")\\n cheese.analyze()\\n assert math.isclose(cheese.catphan_roll, -3.25, abs_tol=0.05)\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def random_translation(canvas, img):\",\n \"def _sample_z(self, a):\\n r = np.random.rand()\\n return ((1 + r * (a - 1))**2) / a\",\n \"def _get_random_transform(self, img_shape, seed=None):\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if self.rotation_range:\\n theta = np.random.uniform(\\n -self.rotation_range,\\n self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n try: # 1-D array-like or int\\n tx = np.random.choice(self.height_shift_range)\\n tx *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n tx = np.random.uniform(-self.height_shift_range,\\n self.height_shift_range)\\n if np.max(self.height_shift_range) < 1:\\n tx *= img_shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n try: # 1-D array-like or int\\n ty = np.random.choice(self.width_shift_range)\\n ty *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n ty = np.random.uniform(-self.width_shift_range,\\n self.width_shift_range)\\n if np.max(self.width_shift_range) < 1:\\n ty *= img_shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(\\n -self.shear_range,\\n self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(\\n self.zoom_range[0],\\n self.zoom_range[1],\\n 2)\\n\\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\\n\\n channel_shift_intensity = None\\n if self.channel_shift_range != 0:\\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\\n self.channel_shift_range)\\n\\n brightness = None\\n if self.brightness_range is not None:\\n brightness = np.random.uniform(self.brightness_range[0],\\n self.brightness_range[1])\\n\\n transform_parameters = {'theta': theta,\\n 'tx': tx,\\n 'ty': ty,\\n 'shear': shear,\\n 'zx': zx,\\n 'zy': zy,\\n 'flip_horizontal': flip_horizontal,\\n 'flip_vertical': flip_vertical,\\n 'channel_shift_intensity': channel_shift_intensity,\\n 'brightness': brightness}\\n\\n return transform_parameters\",\n \"def mutate_point_rect(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_rect(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_rect(mutated_genome,index)\",\n \"def randomize(self):\\n #first take care of all parameters (from N(0,1))\\n x = self._get_params_transformed()\\n x = np.random.randn(x.size)\\n self._set_params_transformed(x)\\n #now draw from prior where possible\\n x = self._get_params()\\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\\n self._set_params(x)\\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)\",\n \"def _generateObjectPositions(self, num=1, retry=100, radius_scale=1.0, radius_offset=1.0, angle_scale=1.0, angle_offset=0.5*np.pi, z=0.5, near_distance=1.0):\\n def genPos():\\n r = radius_scale * self.np_random.rand() + radius_offset\\n a = -np.pi * angle_scale + angle_offset\\n b = np.pi * angle_scale + angle_offset\\n ang = (b - a) * self.np_random.rand() + a\\n return np.array([r * np.sin(ang), r * np.cos(ang), z])\\n def isNear(pos, poss):\\n for p, o in poss:\\n if np.linalg.norm(p - pos) < near_distance:\\n return True\\n return False\\n def genPosRetry(poss):\\n for i in range(retry):\\n pos = genPos()\\n if not isNear(pos, poss):\\n return pos\\n return genPos()\\n poss = []\\n for i in range(num):\\n pos = genPosRetry(poss)\\n orn = p.getQuaternionFromEuler([0.0, 0.0, 2.0*np.pi*self.np_random.rand()])\\n poss.append((pos, orn))\\n self.np_random.shuffle(poss)\\n return poss\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def random_plane_points(num_points, bounds):\\n\\n # Infer dimension of data from bounds\\n (bounds, dimension) = infer_dimension(bounds)\\n\\n # Generate points and rescale to fit bounds\\n points = np.random.rand(num_points, dimension)\\n unit_mean = [0.5] * dimension\\n shifted_points = points - unit_mean + bounds.mean(axis=1)\\n scale = bounds[:, 1] - bounds[:, 0]\\n rescaled_points = np.dot(shifted_points, np.diag(scale))\\n\\n return rescaled_points\",\n \"def randTheta(k, scale=1):\\n return generatePoints(1, k, scale=scale)[0].reshape((k + 1, -1))\",\n \"def totem_random():\\n random_head()\\n random_head()\\n random_head()\",\n \"def random_transform(self, x):\\n pass\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def cointoss():\\n return random.random() < 0.5\",\n \"def repick(g1_x, g1_y, g1_z):\\n i = random.randint(0, len(g1_x) - 1)\\n x = g1_x[i]\\n y = g1_y[i]\\n z = g1_z[i]\\n return x, y, z\",\n \"def randomizePlayerPose(transform, arena_radius=8):\\n initial_r = arena_radius * random.random()\\n initial_theta = 2 * math.pi * random.random()\\n initial_x = initial_r * math.cos(initial_theta)\\n initial_y = initial_r * math.sin(initial_theta)\\n initial_rotation = 2 * math.pi * random.random()\\n transform.translation.x = initial_x\\n transform.translation.y = initial_y\\n q = tf.transformations.quaternion_from_euler(0, 0, initial_rotation)\\n transform.rotation = Quaternion(q[0], q[1], q[2], q[3])\",\n \"def resample(self):\\n self.X = np.random.uniform(-1, 1, (100, 2))\\n self.generate_y()\\n self.phi = None\\n self.K = 0\\n self.centers = None\\n self.cluster_sizes = None\\n self.g = None\\n self.gamma = None\",\n \"def __call__(self, results):\\n if np.random.rand() > self.prob:\\n return results\\n h, w = results['image'].shape[:2]\\n center = self.center\\n if center is None:\\n center = ((w - 1) * 0.5, (h - 1) * 0.5)\\n angle = random_negative(self.angle, self.random_negative_prob)\\n self._rotate_img(results, angle, center, self.scale)\\n return results\",\n \"def move(self):\\n if self._z >= 75:\\n a = random.random()\\n print(str(a))\\n if a < 0.2:\\n self._z += 1\\n if a > 0.2 and a < 0.9:\\n self._z -= 1\\n if a > 0.9:\\n self._z = self._z\\n else: \\n self._z -= 1\\n \\n b = random.random()\\n print(str(b))\\n if b < 0.1:\\n self._y += 1\\n if b > 0.1 and b < 0.2:\\n self._y -= 1\\n if b > 0.2 and b < 0.25:\\n self._x -= 1\\n if b > 0.25:\\n self._x += 1\",\n \"def random_sample(grid_size):\\r\\n g = grid_size\\r\\n x_range = g[1] - g[0]\\r\\n\\r\\n y_range = g[3] - g[2]\\r\\n\\r\\n x_off = g[0]\\r\\n y_off = g[2]\\r\\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \\r\\n return (x,y)\",\n \"def generate_random_DC_crack_coupled_tensor():\\n # 1. Generate random DC MT and crack MT:\\n # generate DC MT:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\\n # Get between small range:\\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\\n random_num = random.random()\\n if random_num <= 0.5:\\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\\n elif random_num > 0.5:\\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n # And redistribute evenly everywhere on boundary:\\n random_num = random.random()\\n if random_num>0.25 and random_num<=0.5:\\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\\n if random_num>0.5 and random_num<=0.75:\\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\\n if random_num>0.75 and random_num<=1.0:\\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\\n # --- ---\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # theta_lune_sphere = random.random()*np.pi/2.\\n # elif random_num > 0.5:\\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # phi_lune_sphere = np.pi/6.\\n # elif random_num > 0.5:\\n # phi_lune_sphere = -1.*np.pi/6.\\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\\n # 2. Combine DC and crack tensors:\\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\\n # 3. Randomly rotate DC-crack MT to random orientation:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\\n # 4. Normalise and get 6 MT:\\n # Get 6 MT:\\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\\n # And normallise so that moment tensor magnitude = 1:\\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\\n return DC_crack_six_MT_rotated_normalised, random_amp_frac\",\n \"def shift_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def get_random_translations(atom_pos, beam_focus_size, jet_radius):\\n N = len(atom_pos)\\n beam_focus_radius = beam_focus_size/2\\n flag = True\\n while(flag):\\n x_trans = beam_focus_radius*np.random.uniform(-1, 1)\\n y_trans = beam_focus_radius*np.random.uniform(-1, 1)\\n z_trans = jet_radius*np.random.uniform(-1, 1)\\n trans = [[x_trans, y_trans, z_trans]]*N\\n trans = np.asarray(trans)\\n new_pos = atom_pos + trans\\n print (\\\"trans_new_pos\\\", new_pos)\\n for i in range(N):\\n if (np.sqrt(new_pos[i][0]**2 + new_pos[i][1]**2) >= beam_focus_radius):\\n flag = False\\n break\\n else:\\n flag = False\\n return new_pos\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def aecSpaceRandomTowers():\\n origin = aecPoint(0, 0, 0)\\n displace = 175\\n spacer = aecSpacer()\\n shaper = aecShaper()\\n \\n def full(point, xWidth, yDepth, zHeight, level):\\n floor = aecSpace()\\n floor.boundary = shaper.makeBox(point, xWidth, yDepth)\\n floor.height = zHeight\\n floor.level = level\\n setColors([floor])\\n return [floor]\\n \\n def halfDepth(point, xWidth, yDepth, zHeight, level):\\n depth = yDepth * 0.5\\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, xWidth, depth)\\n half1.height = zHeight\\n half1.level = level\\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def halfWidth(point, xWidth, yDepth, zHeight, level):\\n width = xWidth * 0.5\\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, width, yDepth)\\n half1.height = zHeight\\n half1.level = level\\n halfSpaces = [half1] + spacer.row(half1)\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def quarterDepth(point, xWidth, yDepth, zHeight, level):\\n if randint(0, 1) == 0:\\n depth = yDepth * 0.25\\n scale = 3\\n else:\\n depth = yDepth * 0.75\\n scale = 0.333333333 \\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, xWidth, depth)\\n half1.height = zHeight\\n half1.level = level \\n halfSpaces = [half1] + spacer.row(half1, xAxis = False)\\n halfSpaces[1].scale(1, scale, 1, halfSpaces[1].points_floor[0])\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def quarterWidth(point, xWidth, yDepth, zHeight, level):\\n if randint(0, 1) == 0:\\n width = xWidth * 0.25\\n scale = 3\\n else:\\n width = xWidth * 0.75\\n scale = 0.333333333 \\n half1 = aecSpace() \\n half1.boundary = shaper.makeBox(point, width, yDepth)\\n half1.height = zHeight\\n half1.level = level \\n halfSpaces = [half1] + spacer.row(half1)\\n halfSpaces[1].scale(scale, 1, 1, halfSpaces[1].points_floor[0])\\n setColors(halfSpaces)\\n return halfSpaces\\n \\n def setColors(halfSpaces):\\n colors = [aecColor.blue, aecColor.orange, aecColor.purple, aecColor.yellow]\\n colorPick = randint(0, 3)\\n halfSpaces[0].color = colors[colorPick]\\n if len(halfSpaces) == 1: return\\n colors.reverse()\\n halfSpaces[1].color = colors[colorPick]\\n \\n def makeFloor(point, xWidth, yDepth, zHeight, level):\\n floorType = randint(0, 4)\\n if floorType == 0: floorSpaces = full(point, xWidth, yDepth, zHeight, level)\\n if floorType == 1: floorSpaces = halfDepth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 2: floorSpaces = halfWidth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 3: floorSpaces = quarterDepth(point, xWidth, yDepth, zHeight, level)\\n if floorType == 4: floorSpaces = quarterWidth(point, xWidth, yDepth, zHeight, level)\\n return floorSpaces\\n \\n def makeCore(point, xWidth, yDepth, zHeight): \\n xCoord = (point.x - 5) + (xWidth * 0.5)\\n yCoord = (point.y + (yDepth * (randint(0, 9) * 0.1)))\\n point = aecPoint(xCoord, yCoord, point.z)\\n core = aecSpace()\\n core.boundary = shaper.makeBox(point, 10, 20)\\n core.height = zHeight\\n core.color = aecColor.gray\\n return [core]\\n \\n def makeTower(point):\\n floors = []\\n xWidth = uniform(20, 60)\\n yDepth = uniform(20, 60)\\n levels = randint(5, 50)\\n zHeight = uniform(3, 6)\\n plinth = aecSpace()\\n plinth.boundary = shaper.makeBox(point, xWidth, yDepth)\\n plinthScaleX = (uniform(1, 2.5))\\n plinthScaleY = (uniform(1, 2.5))\\n plinth.scale(plinthScaleX, plinthScaleY, 2, plinth.centroid_floor)\\n plinth.height = (zHeight * 2)\\n plinth.color = aecColor.green\\n floors.append(plinth)\\n floors = floors + makeCore(point, xWidth, yDepth, zHeight * (levels + 3))\\n level = (zHeight * 2)\\n x = 0\\n while x < levels:\\n floors = floors + makeFloor(point, xWidth, yDepth, zHeight, level)\\n level += zHeight\\n x += 1 \\n return floors\\n \\n def makeTowerRow(point, columns, displacement):\\n towers = []\\n towers = towers + makeTower(point)\\n x = 0\\n while x < columns:\\n point.x += displacement\\n towers = towers + makeTower(point)\\n x += 1\\n return towers\\n \\n def makeTowerRows(point, displacement, columns, rows):\\n towers = []\\n x = 0\\n while x < rows:\\n towers = towers + makeTowerRow(point, columns, displacement)\\n point.x = 0\\n point.y += displacement\\n x += 1\\n return towers\\n \\n return makeTowerRows(origin, displace, 4, 5)\",\n \"def sample_preimage(self, point, seed=None):\\r\\n [[a, b], [c, d]] = self.B0_fft\\r\\n\\r\\n # We compute a vector t_fft such that:\\r\\n # (fft(point), fft(0)) * B0_fft = t_fft\\r\\n # Because fft(0) = 0 and the inverse of B has a very specific form,\\r\\n # we can do several optimizations.\\r\\n '''\\r\\n print(\\\"---------Inside sample_preimage----------\\\")\\r\\n print(\\\"point: \\\", point)\\r\\n '''\\r\\n\\r\\n point_fft = fft(point)\\r\\n\\r\\n t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]\\r\\n t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]\\r\\n t_fft = [t0_fft, t1_fft]\\r\\n\\r\\n # We now compute v such that:\\r\\n # v = z * B0 for an integral vector z\\r\\n # v is close to (point, 0)\\r\\n if seed is None:\\r\\n # If no seed is defined, use urandom as the pseudo-random source.\\r\\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)\\r\\n\\r\\n else:\\r\\n # If a seed is defined, initialize a ChaCha20 PRG\\r\\n # that is used to generate pseudo-randomness.\\r\\n chacha_prng = ChaCha20(seed)\\r\\n z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,\\r\\n chacha_prng.randombytes)\\r\\n\\r\\n v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))\\r\\n v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))\\r\\n v0 = [int(round(elt)) for elt in ifft(v0_fft)]\\r\\n v1 = [int(round(elt)) for elt in ifft(v1_fft)]\\r\\n\\r\\n # The difference s = (point, 0) - v is such that:\\r\\n # s is short\\r\\n # s[0] + s[1] * h = point\\r\\n s = [sub(point, v0), neg(v1)]\\r\\n return s\",\n \"def random():\\n np.random.seed(0)\",\n \"def modify_pt(pt=None,):\\n global dim\\n mod_rand_pt = []\\n\\n for i_ in range(dim):\\n for j_ in range(i_, dim):\\n mod_rand_pt.append(pt[i_] * pt[j_])\\n\\n mod_rand_pt.append(1.)\\n return mod_rand_pt\",\n \"def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]]) # rotate along y axis\\n shape_pc = batch_data[k,:,0:3]\\n shape_normal = batch_data[k,:,3:6]\\n rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)\\n return rotated_data\",\n \"def remove_point(mutated_genome,index):\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n del mutated_genome[index][2][point_index]\",\n \"def move_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\\n point = (Xval,Yval)\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n mutated_genome[index][2][point_index] = point\",\n \"def rand_raster(center, step_size, num_points, random):\\n xscan = []\\n yscan = []\\n \\n xcenter = center[0] # first element of center array\\n ycenter = center[1] # second element of center array\\n \\n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\\n \\n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n \\n # Creates two arrays xscan and yscan\\n for step, ystep in enumerate(yrange):\\n xscan.append(xrange[::(-1)**step])\\n yscan.append(np.ones_like(xrange) * ystep)\\n \\n xscan = np.concatenate(xscan)\\n yscan = np.concatenate(yscan)\\n \\n # Combine the two arrays into a list of vectors\\n raster = []\\n \\n for i in range(0, len(xscan)):\\n scan_element = []\\n \\n scan_element.append(xscan[i])\\n scan_element.append(yscan[i])\\n raster.append(scan_element)\\n \\n return raster\",\n \"def generate(random, lower, upper, count=1):\\n if count > 1:\\n points = []\\n\\n for x in range(lower.x, upper.x):\\n for y in range(lower.y, upper.y):\\n points.append(Point(x, y)) # REFACTOR: Not very efficient\\n\\n return random.sample(points, count)\\n else:\\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))\",\n \"def _sample_using_random(\\n self,\\n p: float = 0.1,\\n ):\\n return sa.func.random() < p\",\n \"def random_transform(self, x, seed=None):\\n # x is a single audio, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\\n input_length = x.shape[img_row_axis]\\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\\n if x.shape[img_row_axis] >= input_length:\\n x = x[:input_length]\\n else:\\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\\n 'constant', constant_values=(0, np.mean(x)))\\n\\n if shift:\\n hx = np.random.uniform(-self.shift, self.shift)\\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\\n\\n if self.roll_range:\\n tx = np.random.uniform(-self.roll_range, self.roll_range)\\n if self.roll_range < 1:\\n tx *= x.shape[img_row_axis]\\n x = np.roll(x, int(tx), axis=(img_row_axis))\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = np.flip(x, axis=img_row_axis)\\n\\n if (self.noise):\\n if np.random.random() < 0.5:\\n if self.noise[-1] == 'Uniform':\\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\\n elif self.noise[-1] == 'Normal':\\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\\n\\n if self.brightness_range is not None:\\n x = random_brightness(x, self.brightness_range)\\n\\n return x\",\n \"def get_transforms(partition: str, num_points: int = 1024,\\n noise_type: str = 'clean', rot_mag: float = 45.0,\\n trans_mag: float = 0.5, partial_p_keep: List = None):\\n\\n partial_p_keep = partial_p_keep if partial_p_keep is not None else [0.7, 0.7]\\n\\n if noise_type == \\\"clean\\\":\\n # 1-1 correspondence for each point (resample first before splitting), no noise\\n if partition == 'train':\\n transforms = [Transforms.Resampler(num_points),\\n Transforms.SplitSourceRef(),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetDeterministic(),\\n Transforms.FixedResampler(num_points),\\n Transforms.SplitSourceRef(),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"jitter\\\":\\n # Points randomly sampled (might not have perfect correspondence), gaussian noise to position\\n if partition == 'train':\\n transforms = [Transforms.SetJitterFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetJitterFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"crop\\\":\\n # Both source and reference point clouds cropped, plus same noise in \\\"jitter\\\"\\n if partition == 'train':\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCrop(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCrop(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n\\n elif noise_type == \\\"cropinv\\\":\\n # Both source and reference point clouds cropped, plus same noise in \\\"jitter\\\"\\n if partition == 'train':\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCropinv(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n transforms = [Transforms.SetCorpFlag(),\\n Transforms.SetDeterministic(),\\n Transforms.SplitSourceRef(),\\n Transforms.Resampler(num_points),\\n Transforms.RandomTransformSE3_euler(rot_mag=rot_mag, trans_mag=trans_mag),\\n Transforms.RandomCropinv(partial_p_keep),\\n Transforms.RandomJitter(),\\n Transforms.ShufflePoints()]\\n else:\\n raise NotImplementedError\\n\\n return transforms\",\n \"def randomize(self):\\r\\n # first take care of all parameters (from N(0,1))\\r\\n x = self._get_params_transformed()\\r\\n x = np.random.randn(x.size)\\r\\n self._set_params_transformed(x)\\r\\n # now draw from prior where possible\\r\\n x = self._get_params()\\r\\n if self.priors is not None:\\r\\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\\r\\n self._set_params(x)\\r\\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\\r\",\n \"def flip(p=0.5):\\n return np.random.random() < p\",\n \"def image_rotate(Xb, batch_size):\\n for i in np.random.choice(batch_size, int(batch_size * p), replace = False):\\n delta = 30. * intensity # scale by self.intensity\\n Xb[i] = rotate(Xb[i], random.uniform(-delta, delta), mode = 'edge')\\n return Xb\",\n \"def reset(self):\\n newPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\\n self.pot = np.asarray(newPerm)\",\n \"def augmenter(x, y):\\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\\n # as 3D microscopy acquisitions are usually not axially symmetric\\n x, y = random_fliprot(x, y, axis=(1, 2))\\n x = random_intensity_change(x)\\n return x, y\",\n \"def unforeseen():\\r\\n return random.gauss(300., 100.)\",\n \"def rotate_point_cloud_in_plane(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, -sinval, 0],\\n [sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def random():\\n np.random.seed(1939)\",\n \"def randomize(self, amplitude):\\n from random import gauss\\n # update alignment from projections\\n self.getMarkersFromTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\\n\\n # add random amplitude\\n # markers\\n irefmark = self.TiltSeries_._TiltAlignmentParas.irefmark\\n for (imark, mark) in enumerate(self._Markers):\\n if (imark + 1) != irefmark:\\n r = mark.get_r()\\n for ii in range(0, 3):\\n r[ii] = gauss(0, amplitude) + r[ii]\\n self._Markers[imark].set_r(r)\\n\\n ireftilt = self.TiltSeries_._TiltAlignmentParas.ireftilt\\n # translations, rotations, magnifications\\n for itilt in range(0, self._ntilt):\\n self._alignmentTransX[ii] = self._alignmentTransX[ii] + gauss(0, amplitude)\\n self._alignmentTransY[ii] = self._alignmentTransY[ii] + gauss(0, amplitude)\\n self._alignmentRotations[ii] = self._alignmentRotations[ii] + gauss(0, amplitude)\\n if (self._projIndices[itilt] != ireftilt):\\n self._alignmentMagnifications[ii] = self._alignmentMagnifications[ii] + gauss(0, amplitude)\\n\\n # update alignment from projections\\n self.setMarkersInTiltSeries(self.TiltSeries_)\\n self.getTranslationsFromTiltSeries(self.TiltSeries_)\\n self.getRotationsFromTiltSeries(self.TiltSeries_)\\n self.getMagnificationsFromTiltSeries(self.TiltSeries_)\",\n \"def sample_from_belief(self):\\n if self._use_information_bottleneck:\\n posteriors = [torch.distributions.Normal(m, torch.sqrt(s)) for m, s in zip(torch.unbind(self.z_means), torch.unbind(self.z_vars))]\\n z = [d.rsample() for d in posteriors]\\n self.z = torch.stack(z)\\n else:\\n self.z = self.z_means\",\n \"def rndSphere():\\n sph = [0,0,0]\\n \\n sph[2] = random.uniform(-1.0,1.0)\\n z2 = math.sqrt(1.0 - sph[2]*sph[2])\\n phi = (2. * math.pi) * random.random()\\n sph[0] = z2 * math.cos(phi)\\n sph[1] = z2 * math.sin(phi)\\n \\n return sph\",\n \"def importance_sampling_step(self, positions, analytic):\\n \\\"\\\"\\\"With upgrad method for suggetion of new positions.\\\"\\\"\\\"\\n \\\"\\\"\\\"Given through the Langevin equation.\\n D is the diffusion coefficient equal 0.5, xi is a gaussion random\\n variable and delta_t is the time step between 0.001 and 0.01\\\"\\\"\\\"\\n\\n D = 0.5\\n greens_function = 0.0\\n\\n if analytic == True:\\n F_old = self.w.quantum_force(positions)\\n else:\\n F_old = self.w.quantum_force_numerical(positions)\\n\\n # r = random.random()*random.choice((-1, 1))\\n # r = np.random.normal()\\n r = np.zeros(self.num_d)\\n for i in range(self.num_d):\\n r[i] = random.gauss(0, 1)\\n # Pick a random particle and calculate new position\\n random_index = random.randrange(len(positions))\\n new_positions = np.array(positions)\\n\\n term1 = D*F_old[random_index, :]*self.delta_t\\n term2 = r*np.sqrt(self.delta_t)\\n new_random_position = new_positions[random_index, :] + term1 + term2\\n new_positions[random_index, :] = new_random_position\\n\\n # Check if wave function is zero\\n test_wavefunction = self.w.wavefunction(new_positions)\\n if test_wavefunction**2 <= 1e-14:\\n pass\\n else:\\n prob_ratio = self.w.wavefunction_ratio(positions, new_positions)\\n\\n if analytic == True:\\n F_new = self.w.quantum_force(new_positions)\\n else:\\n F_new = self.w.quantum_force_numerical(new_positions)\\n\\n for i in range(self.num_p):\\n for j in range(self.num_d):\\n term1 = 0.5*((F_old[i, j] + F_new[i, j]) *\\n (positions[i, j] - new_positions[i, j]))\\n term2 = D*self.delta_t*(F_old[i, j] - F_new[i, j])\\n greens_function += term1 + term2\\n\\n greens_function = np.exp(greens_function)\\n\\n epsilon = np.random.sample()\\n acceptance_ratio = prob_ratio*greens_function\\n\\n if acceptance_ratio > epsilon:\\n positions = new_positions\\n self.s.distances_update(positions, random_index)\\n self.c += 1.0\\n\\n else:\\n pass\\n\\n return positions\",\n \"def Generate_Random( self ):\\n print( 'Generating Random coordinates' )\\n stands = self.Data.Stand.keys()\\n stands.sort()\\n for s in stands:\\n trees = self.Data.Stand[s].Tree.keys()\\n trees.sort()\\n for t in trees:\\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )\",\n \"def test_randoms():\\n\\n # generate two locusts of points\\n npts = 200\\n epsilon = 0.3\\n # #cluster 1\\n coords1 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\\n coords2 = generate_locus_of_3d_points(npts, 0.0, 0.0, 0.0, epsilon=epsilon)\\n\\n # generate orientation vectors for cluster 1\\n vectors1 = normalized_vectors(np.random.random((npts, 3)) * 2.0 - 1.0)\\n\\n # define radial bins\\n rbins = np.array([0.0, 0.1, 2.0 * epsilon])\\n s = np.zeros((npts, 3))\\n\\n s[:, 0] = coords2[:, 0] - coords1[:, 0]\\n s[:, 1] = coords2[:, 1] - coords1[:, 1]\\n s[:, 2] = coords2[:, 2] - coords1[:, 2]\\n\\n dist_a = s[:, 0] ** 2 + s[:, 1] ** 2 + s[:, 2] ** 2\\n\\n # define weights appropiate for weighting function\\n weights1 = np.ones((npts, 4))\\n weights1[:, 1] = vectors1[:, 0]\\n weights1[:, 2] = vectors1[:, 1]\\n weights1[:, 3] = vectors1[:, 2]\\n weights2 = np.ones(npts)\\n\\n # weighting 1\\n # calculate weighted counts\\n weighted_counts, counts = positional_marked_npairs_3d(\\n coords1,\\n coords2,\\n rbins,\\n period=None,\\n weights1=weights1,\\n weights2=weights2,\\n weight_func_id=1,\\n num_threads=1,\\n )\\n\\n msg = (\\n \\\"weighted counts do not match expected result given the weighting function\\\"\\n + \\\" \\\"\\n + str(np.max(dist_a))\\n )\\n assert np.isclose(weighted_counts[-1], 0.0 * counts[-1], atol=4000), msg\",\n \"def generate(self) -> np.ndarray:\\n self.sample_r()\\n self.sample_z()\\n ind: np.ndarray = np.less_equal(self.z_sample, self.r_sample)\\n self.r_sample = self.r_sample[ind]\\n self.z_sample = self.z_sample[ind]\\n return np.sort(np.sqrt(np.subtract(np.square(self.r_sample), np.square(self.z_sample))))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6232219","0.61596","0.6088852","0.6088638","0.60208404","0.59796554","0.5843116","0.5838049","0.5800207","0.57714236","0.5765245","0.57596815","0.5742337","0.57243687","0.5712514","0.57068694","0.5703828","0.5692578","0.5684955","0.5684955","0.5684955","0.567044","0.5668316","0.5656708","0.56275225","0.56183785","0.5616456","0.56098604","0.559919","0.5583931","0.55806917","0.55603033","0.5538127","0.5538127","0.55338615","0.5533376","0.5513924","0.5506339","0.5502098","0.54980576","0.5497877","0.549549","0.54914886","0.54912734","0.54828346","0.5482352","0.54821587","0.54794824","0.54779845","0.5473087","0.54726696","0.5470677","0.54467267","0.544418","0.54438883","0.54385275","0.54271686","0.5417527","0.5391912","0.539","0.5389742","0.53892773","0.538549","0.5382139","0.53821266","0.53813535","0.5374746","0.5371321","0.5370104","0.5368116","0.53667176","0.53650427","0.5362146","0.5359498","0.53506416","0.53493357","0.53425837","0.5340214","0.5337004","0.5330375","0.53209245","0.5316836","0.531374","0.5311528","0.5311434","0.5309292","0.53075016","0.5305779","0.53004146","0.52960736","0.52895176","0.5289277","0.5268059","0.5267382","0.526639","0.5261772","0.5256745","0.5256221","0.52549887","0.52494866"],"string":"[\n \"0.6232219\",\n \"0.61596\",\n \"0.6088852\",\n \"0.6088638\",\n \"0.60208404\",\n \"0.59796554\",\n \"0.5843116\",\n \"0.5838049\",\n \"0.5800207\",\n \"0.57714236\",\n \"0.5765245\",\n \"0.57596815\",\n \"0.5742337\",\n \"0.57243687\",\n \"0.5712514\",\n \"0.57068694\",\n \"0.5703828\",\n \"0.5692578\",\n \"0.5684955\",\n \"0.5684955\",\n \"0.5684955\",\n \"0.567044\",\n \"0.5668316\",\n \"0.5656708\",\n \"0.56275225\",\n \"0.56183785\",\n \"0.5616456\",\n \"0.56098604\",\n \"0.559919\",\n \"0.5583931\",\n \"0.55806917\",\n \"0.55603033\",\n \"0.5538127\",\n \"0.5538127\",\n \"0.55338615\",\n \"0.5533376\",\n \"0.5513924\",\n \"0.5506339\",\n \"0.5502098\",\n \"0.54980576\",\n \"0.5497877\",\n \"0.549549\",\n \"0.54914886\",\n \"0.54912734\",\n \"0.54828346\",\n \"0.5482352\",\n \"0.54821587\",\n \"0.54794824\",\n \"0.54779845\",\n \"0.5473087\",\n \"0.54726696\",\n \"0.5470677\",\n \"0.54467267\",\n \"0.544418\",\n \"0.54438883\",\n \"0.54385275\",\n \"0.54271686\",\n \"0.5417527\",\n \"0.5391912\",\n \"0.539\",\n \"0.5389742\",\n \"0.53892773\",\n \"0.538549\",\n \"0.5382139\",\n \"0.53821266\",\n \"0.53813535\",\n \"0.5374746\",\n \"0.5371321\",\n \"0.5370104\",\n \"0.5368116\",\n \"0.53667176\",\n \"0.53650427\",\n \"0.5362146\",\n \"0.5359498\",\n \"0.53506416\",\n \"0.53493357\",\n \"0.53425837\",\n \"0.5340214\",\n \"0.5337004\",\n \"0.5330375\",\n \"0.53209245\",\n \"0.5316836\",\n \"0.531374\",\n \"0.5311528\",\n \"0.5311434\",\n \"0.5309292\",\n \"0.53075016\",\n \"0.5305779\",\n \"0.53004146\",\n \"0.52960736\",\n \"0.52895176\",\n \"0.5289277\",\n \"0.5268059\",\n \"0.5267382\",\n \"0.526639\",\n \"0.5261772\",\n \"0.5256745\",\n \"0.5256221\",\n \"0.52549887\",\n \"0.52494866\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5757105"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":9469,"cells":{"query":{"kind":"string","value":"Randomly jitter points. jittering is per point."},"document":{"kind":"string","value":"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data"},"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 jitter(interval):\n\treturn interval * (0.9 + 0.2 * random.random())","def rand_int_jitter():\n return random.randint(0, 10)","def jitter(x, y): \r\n dx = max(x) - min(x)\r\n dy = max(y) - min(y)\r\n assert(dx > 0)\r\n assert(dy > 0)\r\n d = math.sqrt(float(dx**2 + dy**2))\r\n print 'dx=%d,dy=%d,d=%f' % (dx,dy,d)\r\n assert(d > 0)\r\n F = 1.0/15.0\r\n fx = F*dx/d\r\n fy = F*dy/d\r\n \r\n def j(xx, yy):\r\n r = random.random() * d\r\n t = random.random() * 2.0 * math.pi\r\n return xx+r*math.cos(t)*fx, yy+r*math.sin(t)*fy\r\n \r\n xy = [j(x[i],y[i]) for i in range(len(x))] \r\n return zip(*xy)","def JitterPoints(points, sigma=0.01): \n C = 3\n assert(points.shape[1] == C)\n\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\n return points + randJitters","def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\n for sampling_result, img_meta in zip(sampling_results, img_metas):\n bboxes = sampling_result.pos_bboxes\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\n -amplitude, amplitude)\n # before jittering\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\n # after jittering\n new_cxcy = cxcy + wh * random_offsets[:, :2]\n new_wh = wh * (1 + random_offsets[:, 2:])\n # xywh to xyxy\n new_x1y1 = (new_cxcy - new_wh / 2)\n new_x2y2 = (new_cxcy + new_wh / 2)\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\n # clip bboxes\n max_shape = img_meta['img_shape']\n if max_shape is not None:\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\n\n sampling_result.pos_bboxes = new_bboxes\n return sampling_results","def jitter(self):\n self.logger.debug(\"Generating jitter\")\n if callable(self._jitter):\n jitter = self._jitter()\n self.logger.debug(\"Jitter is a callable. Returned %s\", jitter)\n else:\n jitter = self._jitter\n self.logger.debug(\"Jitter is a value, '%s'\", jitter)\n \n \n self._last_jitter = jitter\n return jitter","def jitter_data(X, std, datum_jitter=False):\n if not isinstance(X, np.ndarray):\n raise TypeError(\"X must be a numpy array\")\n\n if datum_jitter:\n row = np.random.randint(0, X.shape[0])\n d = X.shape[1]\n X[row, :] = np.random.multivariate_normal(X[row, :], np.eye(d)*std)\n return X\n else:\n return X + np.random.randn(*X.shape)*std","def rand_jitter(arr, magnitude=0.01):\n stdev = magnitude * (max(arr) - min(arr))\n return arr + np.random.randn(len(arr)) * stdev","def jitter(a, jitter_base_prop=.1, jitter_spread_prop=.05,\n base=None, spread=None, ax=None, seed=None, **kwargs):\n\n a = np.array(a)\n if ax is None:\n ax = plt.gca()\n xmin, xmax, ymin, ymax = ax.axis()\n\n # alias_map = dict(size=\"s\", color=\"c\")\n # for attr, alias in alias_map.items():\n # if alias in kwargs:\n # kwargs[attr] = kwargs.pop(alias)\n kwargs.setdefault(\"color\", 'black')\n kwargs.setdefault('s', 1)\n\n height = ymax - ymin\n if base is None:\n base = jitter_base_prop * height + ymin\n if spread is None:\n spread = jitter_spread_prop * height\n\n if seed is None:\n seed = np.random.seed(seed)\n y = np.random.uniform(low=base - spread, high=base + spread, size=len(a))\n\n plt.scatter(a, y, zorder=2, **kwargs)","def jitter(self):\n return self._jitter","def jitter(at, size, spread=0.25, distribution=np.random.rand):\n return np.repeat(at, size) - spread/2 + distribution(size) * spread","def generatePoints(centre: Point, radius: float, numPoints: int, jitterRatio: float = 0) -> List[Point]:\n def jitter() -> float:\n diamiter = radius * math.pi * 2\n jitterSize = jitterRatio * diamiter / numPoints\n return random.random() * 2 * jitterSize - jitterSize\n\n points: List[Point] = []\n angle_segment = math.pi * 2 / numPoints\n angle = 0\n\n while angle < math.pi * 2:\n point = (centre[0] + radius * math.cos(angle) + jitter(),\n centre[1] + radius * math.sin(angle) + jitter())\n points.append(point)\n angle += angle_segment\n\n return points","def _compute_jitters(self):\n self._jitters = []\n self._jitter_index = 0\n scale = 1.0 / float(Globals.native_resolution.x)\n\n # Reduce jittering to 35% to avoid flickering\n scale *= 0.35\n\n for x, y in JITTERS[self.get_setting(\"jitter_pattern\")]:\n jitter_x = (x * 2 - 1) * scale * 0.5\n jitter_y = (y * 2 - 1) * scale * 0.5\n self._jitters.append((jitter_x, jitter_y))","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def captureNewDataPoint(self):\n return 2.0*rand()-1.0","def generate_random_point(xmin,xmax,ymin,ymax):\n\tnp.random.seed()\n\tx_rand = np.random.uniform(xmin,xmax)\n\ty_rand = np.random.uniform(ymin,ymax)\n\treturn(x_rand,y_rand)","def generateData(numPoints,x,y):\n\tfor i in range(0,numPoints):\n\t\tif (i % 2 == 0):\n\t\t\tx.append(random.normalvariate(25, 15))\n\t\t\ty.append(random.normalvariate(25, 15))\n\t\t\t \n\t\t\t\n\t\telse:\n\t\t\tx.append(random.normalvariate(75, 15))\n\t\t\ty.append(random.normalvariate(75, 15))","def update_jitter_pattern(self):\n self._compute_jitters()","def random():\n np.random.seed(1939)","def jittered_neuron(t=None, feature=None, n_trial=61, jitter=1.0, gain=0.0, noise=0.05, seed=1234):\n\n # default time base\n if t is None:\n t = np.linspace(-5, 5, 150)\n\n # default feature\n if feature is None:\n feature = lambda tau: np.exp(-(t-tau)**2)\n\n # noise matrix\n np.random.seed(seed)\n noise = noise*np.random.randn(n_trial, len(t))\n\n # generate jittered data\n gains = 1.0 + gain*np.random.randn(n_trial)\n shifts = jitter*np.random.randn(n_trial)\n jittered_data = np.array([g*feature(s) for g, s in zip(gains, shifts)]) + noise\n\n # generate aligned data\n aligned_data = np.array([g*feature(0) for g in gains]) + noise\n\n return feature(0), np.atleast_3d(aligned_data), np.atleast_3d(jittered_data)","def jitter_point_cloud(data, sigma=0.25, clip=1):\n B, N, C = data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += data\n return jittered_data","def jitter_point_cloud(batch_data, sigma=0.02, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data","def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\r\n B, N, C = batch_data.shape\r\n assert(clip > 0)\r\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\r\n jittered_data += batch_data\r\n return jittered_data","def sample_new_observations(self, point, n_samples, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n\n posterior_parameters = self.compute_posterior_parameters(point)\n mean = posterior_parameters['mean']\n var = posterior_parameters['cov']\n\n samples = np.random.normal(mean[0], np.sqrt(var[0, 0]), n_samples)\n\n return samples","def get_random_points(N): \n x1 = np.random.uniform(-1,1,N)\n x2 = np.random.uniform(-1,1,N)\n return (x1,x2)","def jitter(self, percentile=None):\n if self.jitter is None or percentile is None:\n return self.jitter\n return self.jitter[percentile]","def generate_point(self):\n x = random.uniform(0.0, 9999.9)\n y = random.uniform(0.0, 9999.9)\n random_point = Point(x, y)\n assert isinstance(random_point, Point)\n return random_point","def get_random_point(self):\n\t\tx = np.random.uniform(self.xmin, self.xmax)\n\t\ty = np.random.uniform(self.ymin, self.ymax)\n\t\treturn [x, y, 0.0]","def sample_point_from_gp(self, point_to_sample, noise_variance=0.0):\n point = numpy.array(point_to_sample, copy=False, ndmin=2)\n mean = self.compute_mean_of_points(point)[0]\n variance = self.compute_variance_of_points(point)[0, 0]\n\n return mean + numpy.sqrt(variance) * numpy.random.normal() + numpy.sqrt(noise_variance) * numpy.random.normal()","def rand(self):\n raise NotImplementedError","def give_rand_points(n_points, xmin, xmax, ymin, ymax, n_dim=2):\n random_points = np.random.rand(n_points, n_dim)\n random_points[:, 0] = random_points[:, 0]*(xmax-xmin)+xmin\n random_points[:, 1] = random_points[:, 1]*(ymax-ymin)+ymin\n\n return random_points","def run_interpolations_with_random_betas_1d():\n rmse_values = []\n picked_points_values = []\n number_of_times = 100 # this will be the number of points displayed on the graph\n random = np.random.default_rng()\n\n for i in range(0, number_of_times):\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\n 100)) # picks a random number of known points\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\n test_rmse = root_mean_square_error(test_interpolated_points)\n rmse_values.append(test_rmse)\n picked_points_values.append(len(test_picked_points))\n\n plot_numbers(rmse_values, picked_points_values)","def run_interpolations_with_random_betas_1d():\n rmse_values = []\n picked_points_values = []\n number_of_times = 100 # this will be the number of points displayed on the graph\n random = np.random.default_rng()\n\n for i in range(0, number_of_times):\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\n 100)) # picks a random number of known points\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\n test_rmse = root_mean_square_error(test_interpolated_points)\n rmse_values.append(test_rmse)\n picked_points_values.append(len(test_picked_points))\n\n plot_numbers(rmse_values, picked_points_values)","def run_interpolations_with_random_betas_1d():\n rmse_values = []\n picked_points_values = []\n number_of_times = 100 # this will be the number of points displayed on the graph\n random = np.random.default_rng()\n\n for i in range(0, number_of_times):\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\n 100)) # picks a random number of known points\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\n test_rmse = root_mean_square_error(test_interpolated_points)\n rmse_values.append(test_rmse)\n picked_points_values.append(len(test_picked_points))\n\n plot_numbers(rmse_values, picked_points_values)","def elapseTime(self, gameState):\n newParticleList = []\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\n # likely the ghost is to move to that position\n for particle in self.particles:\n newPosDist = self.getPositionDistribution(gameState, particle)\n newParticleList.append(util.sample(newPosDist))\n self.particles = newParticleList","def sample(self):\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\n x = self.x_prev\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\n self.dt\n ) * np.random.normal(size=self.mu.shape)\n self.x_prev = x + dx\n return self.x_prev","def _sample_using_random(\n self,\n p: float = 0.1,\n ):\n return sa.func.random() < p","def test_jitter_results():\n error_tolerance = 0.05 # 5%\n scale = 2.0\n\n df = pd.DataFrame({\"original\": [1] * 1000})\n results = df.jitter(\n column_name=\"original\", dest_column_name=\"jittered\", scale=scale\n )\n assert (\n abs(\n (results[\"jittered\"].mean() - results[\"original\"].mean())\n / results[\"original\"].mean()\n )\n <= error_tolerance\n )\n assert abs((results[\"jittered\"].std() - scale) / scale) <= error_tolerance","def random():\n np.random.seed(0)","def rand(self):\n raise NotImplementedError(\"Not implemented yet.\")","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def random_point(self, n_samples=1, bound=1.0):\n samples = self._iterate_over_factors(\n \"random_point\", {\"n_samples\": n_samples, \"bound\": bound}\n )\n return samples","def randomize_trajectory(self):\n self.angle = randint(-360, 360)\n self.speed = randint(1, 5)/2.5","def mutate_random(self, point, population):\n other = Point(self.model.generate())\n other.evaluate(self.model)\n while other in population or other == point:\n other = Point(self.model.generate())\n other.evaluate(self.model)\n return other","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def time_per_part():\r\n return random.normalvariate(PT_MEAN, PT_SIGMA)","def rand(self, x):\r\n return np.random.random(1)[0]","def create_random_points(n):\n\n\treturn [(random.randint(0,n),random.randint(0,n)) for i in range(n)]","def plot_jitter(jitter_ax, col_counter,\r\n wt_x_vals,\r\n wt_self_row_medians,\r\n mt_self_row_medians,\r\n wt_mut_row_medians,\r\n# null_x_vals,\r\n# null_conn,\r\n wt_mut_rep_pval_text,\r\n wt_vs_mut_wt_conn_pval_text,\r\n use_c_pval,\r\n ymin, ymax,\r\n corr_val_str):\r\n x_vals = []\r\n y_vals = []\r\n for i in range(len(wt_self_row_medians)):\r\n y_vals.append(wt_self_row_medians[i])\r\n x_vals.append(wt_x_vals[i])\r\n for val in mt_self_row_medians:\r\n y_vals.append(val)\r\n x_vals.append(random.randint(MUT_RANGE[0], MUT_RANGE[1]))\r\n for val in wt_mut_row_medians:\r\n y_vals.append(val)\r\n x_vals.append(random.randint(CONN_RANGE[0], CONN_RANGE[1]))\r\n# for i in range(len(null_conn)):\r\n# y_vals.append(null_conn[i])\r\n# x_vals.append(null_x_vals[i])\r\n\r\n jitter_ax.plot(x_vals, y_vals,\r\n 'k.',\r\n c=((0,0,0,0.25)))\r\n\r\n jitter_ax.set_ylim(ymin,ymax)\r\n jitter_ax.set_xlim(0, XMAX)\r\n if col_counter == 1:\r\n jitter_ax.set_ylabel(corr_val_str)\r\n\r\n jitter_ax.set_xticks(JITTER_XTICKS)\r\n jitter_ax.set_xticklabels([\"wt\",\r\n \"mut\",\r\n \"wt-mut\",\r\n \"random\"],\r\n# rotation=45,\r\n# ha='right',\r\n size='x-small')\r\n\r\n # Add p-value text\r\n if use_c_pval:\r\n pval_type = \"cP\"\r\n else:\r\n pval_type = \"P\"\r\n jitter_ax.text(2,\r\n ymin/3,\r\n \"wt_vs_mut_%s:\\n\" % pval_type + wt_mut_rep_pval_text,\r\n size='x-small')\r\n\r\n jitter_ax.text(XMAX - 2,\r\n ymin/3,\r\n \"wt_vs_conn_%s:\\n\" % pval_type + wt_vs_mut_wt_conn_pval_text,\r\n ha='right',\r\n size='x-small')","def mutate(self, size):\n rand = random.random()\n if rand <= 0.5:\n print u\"changing colour\"\n idx = random.randrange(0, 4)\n value = random.randrange(0, 256)\n colour = list(self.colour)\n colour[idx] = value\n self.colour = tuple(colour)\n else:\n print u\"changing point\"\n idx = random.randrange(0, len(self.points))\n point = generate_point(size[0], size[1])\n self.points[idx] = point","def increment_point(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-2))\n seed = random.randint(0,2)\n if seed == 0:\n point_index2 = point_index1 + 1\n elif seed == 1:\n point_index2 = random.randint(point_index1,max(0,len(mutated_genome[index][2])-1))\n else: #seed == 2:\n point_index2 = max(0,len(mutated_genome[index][2])-1)\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def totem_random():\n random_head()\n random_head()\n random_head()","def random():\r\n return R.NextDouble()","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def random_transform(self, x):\n pass","def perturb_point(self, x, scale):\n x_samp = x + (scale / 2.0) * (np.random.rand(3) - 0.5)\n return x_samp","def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def RandomDelay():\r\n sleep(random())","def jitter_under_thresh(x: xr.DataArray, thresh: float):\n epsilon = np.finfo(x.dtype).eps\n if uses_dask(x):\n jitter = dsk.random.uniform(\n low=epsilon, high=thresh, size=x.shape, chunks=x.chunks\n )\n else:\n jitter = np.random.uniform(low=epsilon, high=thresh, size=x.shape)\n return x.where(~((x < thresh) & (x.notnull())), jitter.astype(x.dtype))","def generate(random, lower, upper, count=1):\n if count > 1:\n points = []\n\n for x in range(lower.x, upper.x):\n for y in range(lower.y, upper.y):\n points.append(Point(x, y)) # REFACTOR: Not very efficient\n\n return random.sample(points, count)\n else:\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))","def RandomCoordinate(): \r\n return ReturnRounded(np.random.uniform(-10,10))","def randomizeDelays(self, rand_distr):\n raise NotImplementedError","def rand_djitter(arr):\n stdev = 0.005\n return arr + (-1+2*np.random.random(len(arr)))*stdev","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def random_transform(self, x, seed=None):\n # x is a single audio, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\n input_length = x.shape[img_row_axis]\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\n if x.shape[img_row_axis] >= input_length:\n x = x[:input_length]\n else:\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\n 'constant', constant_values=(0, np.mean(x)))\n\n if shift:\n hx = np.random.uniform(-self.shift, self.shift)\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\n\n if self.roll_range:\n tx = np.random.uniform(-self.roll_range, self.roll_range)\n if self.roll_range < 1:\n tx *= x.shape[img_row_axis]\n x = np.roll(x, int(tx), axis=(img_row_axis))\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = np.flip(x, axis=img_row_axis)\n\n if (self.noise):\n if np.random.random() < 0.5:\n if self.noise[-1] == 'Uniform':\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\n elif self.noise[-1] == 'Normal':\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\n\n if self.brightness_range is not None:\n x = random_brightness(x, self.brightness_range)\n\n return x","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def noise_data(self, x):\n return x + np.random.normal(size=x.shape)","def random_point(self, n_samples=1):\n vertices = self.ambient_manifold.random_point(n_samples * self.n_vertices)\n vertices = gs.reshape(vertices, (n_samples, self.n_vertices, 3))\n return vertices[0] if n_samples == 1 else vertices","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]","def shift_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def Randomize(seed=None):\n random.seed()","def cell_sample(mask, samplingPoints):\n maskedArea = np.array(np.where(mask)).T\n maskedAreaLength = len(maskedArea)\n randomIndex = sp.random.randint(0, maskedAreaLength, samplingPoints)\n coordsRandom = maskedArea[randomIndex] + sp.rand(samplingPoints, 2)\n return(coordsRandom)","def samplepoint(x,u):\n return point(x)","def __randomize_data(self):\n times = map(lambda (t, _): t, self.data)\n coords = map(lambda (_, c): c, self.data)\n return zip(times, map(DataGen.__randomize_coord, coords))","def changeState(self, xyPoints):\n nPts = len(xyPoints)\n ind0 = random.randint(1, nPts-1)\n ind1 = random.randint(1, nPts-1)\n while ind1 == ind0:\n ind1 = random.randint(1, nPts-1)\n # make copy of the sources to make sure the swap works correctly\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])","def pick_poisson_random_points(points, pick_number, lam):\n random = np.random.default_rng()\n\n random_picks = []\n\n while len(random_picks) < pick_number:\n random_num = random.poisson(lam) # picks poisson random number\n if not random_num in random_picks and 0 < random_num < len(\n points): # Checks to make sure number hasnt been picked yet and is within range\n random_picks.append(random_num)\n new_map = {}\n for i in random_picks: # assigns and copies picked points into a new dictionary\n new_map[i] = Point(i, points.get(i).get_actual_pollution_value(), points.get(i).get_x_cord())\n new_map.get(i).read_pollution_value()\n\n return new_map","def gen_lat_lon(self):\n delta = round(random.random() * random.randint(1, 4), 4)\n sign = random.randint(1, 100)\n if sign % 2 == 0:\n self.lat += delta\n else:\n self.lat -= delta\n\n delta = round(random.random() * random.randint(1, 4), 4)\n sign = random.randint(1, 100)\n if sign % 2 == 0:\n self.lon += delta\n else:\n self.lon -= delta","def random_temp():\n temp_min = 154\n temp_max = 500\n temp_interval = 1\n # `range`s are exclusive [min, max)\n return random.randrange(temp_min, temp_max + 1, temp_interval)","def reroll(self):\n self._base_x = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._x_min,\n self.base_point_distribution._x_max\n )\n self._base_y = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._y_min,\n self.base_point_distribution._y_max\n )","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def random(self, n=1):\n # self.num_generated += n","def noise(x: np.ndarray) -> np.ndarray:\n\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)","def scatter_points(n):\r\n P1 = np.random.randn(int(np.ceil(n/2)), 2) - 4\r\n P2 = 3 * np.random.rand(int(np.ceil(n/4)), 2) - np.array([10, 0])\r\n P3 = np.random.randn(int(np.ceil(n/4)), 2) + 3\r\n \"\"\"\r\n P1=np.floor(P1)\r\n P2=np.floor(P2)\r\n P3=np.floor(P3)\r\n \"\"\"\r\n L = list(np.concatenate((P1,P2,P3), axis=0))\r\n \r\n return L \r\n #return no_dupli(L)\r","def rnd_pset(self):\n\t\treturn [rnd() * 10, rnd() * 10, rnd() * 12 * 15, rnd() * 12 * 15]","def salt_and_pepper_noise(image, prob):\n output = np.zeros(image.shape,np.uint8)\n thres = 1 - prob \n for i in range(image.shape[0]):\n for j in range(image.shape[1]):\n rdn = random.random()\n if rdn < prob:\n output[i][j] = 0\n elif rdn > thres:\n output[i][j] = 255\n else:\n output[i][j] = image[i][j]\n return output","def add_salt_pepper_noise(img):\n # Need to produce a copy as to not modify the original image\n dice = random.randint(0, 100)\n\n if (dice < 30):\n row, col, _ = img.shape\n salt_vs_pepper = 0.20\n amount = 0.030\n num_salt = np.ceil(amount * img.size * salt_vs_pepper)\n num_pepper = np.ceil(amount * img.size * (1.0 - salt_vs_pepper))\n\n # Add Salt noise\n coords = [np.random.randint(0, i - 1, int(num_salt)) for i in img.shape]\n img[coords[0], coords[1], :] = 255\n\n # Add Pepper noise\n coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in img.shape]\n img[coords[0], coords[1], :] = 0\n return img","def add_uniform_noise(data, p=1):\n if p < 1:\n raise ValueError(\"'p' has to be greater or equal to 1.\")\n noise = np.random.uniform(-5.*10**(-p), 5*10**(-p), size = len(data))\n randomized_data = data + noise\n # ensure there are no negative entries after noise is added\n randomized_data = \\\n randomized_data[np.where(randomized_data > 0)]\n return randomized_data","def sample_using_point_estimate(self, x:float, x_std:float, k, name, delay, lagged_values, lagged_times):\n return normal_sample_projected(prediction_std=x, prediction_mean=x_std,\n num=self.num_predictions, lagged_values=lagged_values)","def random_float():\n return (random() - 0.5) * 2","def pickup_samples(pts1, pts2):\n\n #\n # Your code here\n #\n\n x = min(len(pts1), len(pts2))\n return np.random.choice(range(x), min_num_pairs(), replace=False)","def MovePoint(pos,points,s=0.5, k = 1000): \n \n x = [pos[0]] \n y = [pos[1]]\n rdm.seed(1) # comment out if you want randomness\n for i in range(k):\n n = len(points)\n r = int(rdm.random()*n)\n \n x.append(x[i] + (points[r][0] - x[i]) * s)\n y.append(y[i] + (points[r][1] - y[i]) * s)\n\n \n return(x,y)","def ternary_noise(N_stimuli, Nx, Ny):\n return np.random.randint(-1, 2, size=(N_stimuli, Nx, Ny))","def random_position():\n path = (\n os.path.dirname(__file__)\n + os.sep\n + \"templates\"\n + os.sep\n + \"data\"\n + os.sep\n + \"taxi_stations.json\"\n )\n with open(path) as f:\n stations = json.load(f)[\"features\"]\n pos = random.choice(stations)\n coords = [pos[\"geometry\"][\"coordinates\"][1], pos[\"geometry\"][\"coordinates\"][0]]\n lat = float(\"{0:.6f}\".format(coords[0]))\n lng = float(\"{0:.6f}\".format(coords[1]))\n return [lat, lng]","def rand_coord(n):\n\n x = random.randint(0, n - 1)\n y = random.randint(0, n - 1)\n return x, y","def _randomVelocity(self):\n\t\treturn random.choice([-1, 1]) * random.randint(10, 50)","def random_importance_function():\n return random()","def generate_random_point_in_domain(self, random_source=None):\n return numpy.array([self._domain.generate_random_point_in_domain(random_source=random_source)\n for _ in xrange(self.num_repeats)])","def data_feeder_2():\n return random.sample(range(100), 10)"],"string":"[\n \"def jitter(interval):\\n\\treturn interval * (0.9 + 0.2 * random.random())\",\n \"def rand_int_jitter():\\n return random.randint(0, 10)\",\n \"def jitter(x, y): \\r\\n dx = max(x) - min(x)\\r\\n dy = max(y) - min(y)\\r\\n assert(dx > 0)\\r\\n assert(dy > 0)\\r\\n d = math.sqrt(float(dx**2 + dy**2))\\r\\n print 'dx=%d,dy=%d,d=%f' % (dx,dy,d)\\r\\n assert(d > 0)\\r\\n F = 1.0/15.0\\r\\n fx = F*dx/d\\r\\n fy = F*dy/d\\r\\n \\r\\n def j(xx, yy):\\r\\n r = random.random() * d\\r\\n t = random.random() * 2.0 * math.pi\\r\\n return xx+r*math.cos(t)*fx, yy+r*math.sin(t)*fy\\r\\n \\r\\n xy = [j(x[i],y[i]) for i in range(len(x))] \\r\\n return zip(*xy)\",\n \"def JitterPoints(points, sigma=0.01): \\n C = 3\\n assert(points.shape[1] == C)\\n\\n randJitters = np.random.uniform(-sigma, sigma, size = points.shape)\\n return points + randJitters\",\n \"def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):\\n for sampling_result, img_meta in zip(sampling_results, img_metas):\\n bboxes = sampling_result.pos_bboxes\\n random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(\\n -amplitude, amplitude)\\n # before jittering\\n cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2\\n wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()\\n # after jittering\\n new_cxcy = cxcy + wh * random_offsets[:, :2]\\n new_wh = wh * (1 + random_offsets[:, 2:])\\n # xywh to xyxy\\n new_x1y1 = (new_cxcy - new_wh / 2)\\n new_x2y2 = (new_cxcy + new_wh / 2)\\n new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)\\n # clip bboxes\\n max_shape = img_meta['img_shape']\\n if max_shape is not None:\\n new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)\\n new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)\\n\\n sampling_result.pos_bboxes = new_bboxes\\n return sampling_results\",\n \"def jitter(self):\\n self.logger.debug(\\\"Generating jitter\\\")\\n if callable(self._jitter):\\n jitter = self._jitter()\\n self.logger.debug(\\\"Jitter is a callable. Returned %s\\\", jitter)\\n else:\\n jitter = self._jitter\\n self.logger.debug(\\\"Jitter is a value, '%s'\\\", jitter)\\n \\n \\n self._last_jitter = jitter\\n return jitter\",\n \"def jitter_data(X, std, datum_jitter=False):\\n if not isinstance(X, np.ndarray):\\n raise TypeError(\\\"X must be a numpy array\\\")\\n\\n if datum_jitter:\\n row = np.random.randint(0, X.shape[0])\\n d = X.shape[1]\\n X[row, :] = np.random.multivariate_normal(X[row, :], np.eye(d)*std)\\n return X\\n else:\\n return X + np.random.randn(*X.shape)*std\",\n \"def rand_jitter(arr, magnitude=0.01):\\n stdev = magnitude * (max(arr) - min(arr))\\n return arr + np.random.randn(len(arr)) * stdev\",\n \"def jitter(a, jitter_base_prop=.1, jitter_spread_prop=.05,\\n base=None, spread=None, ax=None, seed=None, **kwargs):\\n\\n a = np.array(a)\\n if ax is None:\\n ax = plt.gca()\\n xmin, xmax, ymin, ymax = ax.axis()\\n\\n # alias_map = dict(size=\\\"s\\\", color=\\\"c\\\")\\n # for attr, alias in alias_map.items():\\n # if alias in kwargs:\\n # kwargs[attr] = kwargs.pop(alias)\\n kwargs.setdefault(\\\"color\\\", 'black')\\n kwargs.setdefault('s', 1)\\n\\n height = ymax - ymin\\n if base is None:\\n base = jitter_base_prop * height + ymin\\n if spread is None:\\n spread = jitter_spread_prop * height\\n\\n if seed is None:\\n seed = np.random.seed(seed)\\n y = np.random.uniform(low=base - spread, high=base + spread, size=len(a))\\n\\n plt.scatter(a, y, zorder=2, **kwargs)\",\n \"def jitter(self):\\n return self._jitter\",\n \"def jitter(at, size, spread=0.25, distribution=np.random.rand):\\n return np.repeat(at, size) - spread/2 + distribution(size) * spread\",\n \"def generatePoints(centre: Point, radius: float, numPoints: int, jitterRatio: float = 0) -> List[Point]:\\n def jitter() -> float:\\n diamiter = radius * math.pi * 2\\n jitterSize = jitterRatio * diamiter / numPoints\\n return random.random() * 2 * jitterSize - jitterSize\\n\\n points: List[Point] = []\\n angle_segment = math.pi * 2 / numPoints\\n angle = 0\\n\\n while angle < math.pi * 2:\\n point = (centre[0] + radius * math.cos(angle) + jitter(),\\n centre[1] + radius * math.sin(angle) + jitter())\\n points.append(point)\\n angle += angle_segment\\n\\n return points\",\n \"def _compute_jitters(self):\\n self._jitters = []\\n self._jitter_index = 0\\n scale = 1.0 / float(Globals.native_resolution.x)\\n\\n # Reduce jittering to 35% to avoid flickering\\n scale *= 0.35\\n\\n for x, y in JITTERS[self.get_setting(\\\"jitter_pattern\\\")]:\\n jitter_x = (x * 2 - 1) * scale * 0.5\\n jitter_y = (y * 2 - 1) * scale * 0.5\\n self._jitters.append((jitter_x, jitter_y))\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def captureNewDataPoint(self):\\n return 2.0*rand()-1.0\",\n \"def generate_random_point(xmin,xmax,ymin,ymax):\\n\\tnp.random.seed()\\n\\tx_rand = np.random.uniform(xmin,xmax)\\n\\ty_rand = np.random.uniform(ymin,ymax)\\n\\treturn(x_rand,y_rand)\",\n \"def generateData(numPoints,x,y):\\n\\tfor i in range(0,numPoints):\\n\\t\\tif (i % 2 == 0):\\n\\t\\t\\tx.append(random.normalvariate(25, 15))\\n\\t\\t\\ty.append(random.normalvariate(25, 15))\\n\\t\\t\\t \\n\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tx.append(random.normalvariate(75, 15))\\n\\t\\t\\ty.append(random.normalvariate(75, 15))\",\n \"def update_jitter_pattern(self):\\n self._compute_jitters()\",\n \"def random():\\n np.random.seed(1939)\",\n \"def jittered_neuron(t=None, feature=None, n_trial=61, jitter=1.0, gain=0.0, noise=0.05, seed=1234):\\n\\n # default time base\\n if t is None:\\n t = np.linspace(-5, 5, 150)\\n\\n # default feature\\n if feature is None:\\n feature = lambda tau: np.exp(-(t-tau)**2)\\n\\n # noise matrix\\n np.random.seed(seed)\\n noise = noise*np.random.randn(n_trial, len(t))\\n\\n # generate jittered data\\n gains = 1.0 + gain*np.random.randn(n_trial)\\n shifts = jitter*np.random.randn(n_trial)\\n jittered_data = np.array([g*feature(s) for g, s in zip(gains, shifts)]) + noise\\n\\n # generate aligned data\\n aligned_data = np.array([g*feature(0) for g in gains]) + noise\\n\\n return feature(0), np.atleast_3d(aligned_data), np.atleast_3d(jittered_data)\",\n \"def jitter_point_cloud(data, sigma=0.25, clip=1):\\n B, N, C = data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += data\\n return jittered_data\",\n \"def jitter_point_cloud(batch_data, sigma=0.02, clip=0.05):\\n B, N, C = batch_data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += batch_data\\n return jittered_data\",\n \"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\\r\\n B, N, C = batch_data.shape\\r\\n assert(clip > 0)\\r\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\r\\n jittered_data += batch_data\\r\\n return jittered_data\",\n \"def sample_new_observations(self, point, n_samples, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n\\n posterior_parameters = self.compute_posterior_parameters(point)\\n mean = posterior_parameters['mean']\\n var = posterior_parameters['cov']\\n\\n samples = np.random.normal(mean[0], np.sqrt(var[0, 0]), n_samples)\\n\\n return samples\",\n \"def get_random_points(N): \\n x1 = np.random.uniform(-1,1,N)\\n x2 = np.random.uniform(-1,1,N)\\n return (x1,x2)\",\n \"def jitter(self, percentile=None):\\n if self.jitter is None or percentile is None:\\n return self.jitter\\n return self.jitter[percentile]\",\n \"def generate_point(self):\\n x = random.uniform(0.0, 9999.9)\\n y = random.uniform(0.0, 9999.9)\\n random_point = Point(x, y)\\n assert isinstance(random_point, Point)\\n return random_point\",\n \"def get_random_point(self):\\n\\t\\tx = np.random.uniform(self.xmin, self.xmax)\\n\\t\\ty = np.random.uniform(self.ymin, self.ymax)\\n\\t\\treturn [x, y, 0.0]\",\n \"def sample_point_from_gp(self, point_to_sample, noise_variance=0.0):\\n point = numpy.array(point_to_sample, copy=False, ndmin=2)\\n mean = self.compute_mean_of_points(point)[0]\\n variance = self.compute_variance_of_points(point)[0, 0]\\n\\n return mean + numpy.sqrt(variance) * numpy.random.normal() + numpy.sqrt(noise_variance) * numpy.random.normal()\",\n \"def rand(self):\\n raise NotImplementedError\",\n \"def give_rand_points(n_points, xmin, xmax, ymin, ymax, n_dim=2):\\n random_points = np.random.rand(n_points, n_dim)\\n random_points[:, 0] = random_points[:, 0]*(xmax-xmin)+xmin\\n random_points[:, 1] = random_points[:, 1]*(ymax-ymin)+ymin\\n\\n return random_points\",\n \"def run_interpolations_with_random_betas_1d():\\n rmse_values = []\\n picked_points_values = []\\n number_of_times = 100 # this will be the number of points displayed on the graph\\n random = np.random.default_rng()\\n\\n for i in range(0, number_of_times):\\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\\n 100)) # picks a random number of known points\\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\\n test_rmse = root_mean_square_error(test_interpolated_points)\\n rmse_values.append(test_rmse)\\n picked_points_values.append(len(test_picked_points))\\n\\n plot_numbers(rmse_values, picked_points_values)\",\n \"def run_interpolations_with_random_betas_1d():\\n rmse_values = []\\n picked_points_values = []\\n number_of_times = 100 # this will be the number of points displayed on the graph\\n random = np.random.default_rng()\\n\\n for i in range(0, number_of_times):\\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\\n 100)) # picks a random number of known points\\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\\n test_rmse = root_mean_square_error(test_interpolated_points)\\n rmse_values.append(test_rmse)\\n picked_points_values.append(len(test_picked_points))\\n\\n plot_numbers(rmse_values, picked_points_values)\",\n \"def run_interpolations_with_random_betas_1d():\\n rmse_values = []\\n picked_points_values = []\\n number_of_times = 100 # this will be the number of points displayed on the graph\\n random = np.random.default_rng()\\n\\n for i in range(0, number_of_times):\\n test_points = create_points_with_random_pollution_1d(100, 100, 10)\\n test_picked_points = pick_uniform_random_points(test_points, random.integers(1,\\n 100)) # picks a random number of known points\\n test_interpolated_points = interpolate_unknown_points(test_picked_points, test_points)\\n test_rmse = root_mean_square_error(test_interpolated_points)\\n rmse_values.append(test_rmse)\\n picked_points_values.append(len(test_picked_points))\\n\\n plot_numbers(rmse_values, picked_points_values)\",\n \"def elapseTime(self, gameState):\\n newParticleList = []\\n # Pretend each particle is a ghost, and set its position semi-randomly based on how\\n # likely the ghost is to move to that position\\n for particle in self.particles:\\n newPosDist = self.getPositionDistribution(gameState, particle)\\n newParticleList.append(util.sample(newPosDist))\\n self.particles = newParticleList\",\n \"def sample(self):\\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\\n x = self.x_prev\\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\\n self.dt\\n ) * np.random.normal(size=self.mu.shape)\\n self.x_prev = x + dx\\n return self.x_prev\",\n \"def _sample_using_random(\\n self,\\n p: float = 0.1,\\n ):\\n return sa.func.random() < p\",\n \"def test_jitter_results():\\n error_tolerance = 0.05 # 5%\\n scale = 2.0\\n\\n df = pd.DataFrame({\\\"original\\\": [1] * 1000})\\n results = df.jitter(\\n column_name=\\\"original\\\", dest_column_name=\\\"jittered\\\", scale=scale\\n )\\n assert (\\n abs(\\n (results[\\\"jittered\\\"].mean() - results[\\\"original\\\"].mean())\\n / results[\\\"original\\\"].mean()\\n )\\n <= error_tolerance\\n )\\n assert abs((results[\\\"jittered\\\"].std() - scale) / scale) <= error_tolerance\",\n \"def random():\\n np.random.seed(0)\",\n \"def rand(self):\\n raise NotImplementedError(\\\"Not implemented yet.\\\")\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def random_point(self, n_samples=1, bound=1.0):\\n samples = self._iterate_over_factors(\\n \\\"random_point\\\", {\\\"n_samples\\\": n_samples, \\\"bound\\\": bound}\\n )\\n return samples\",\n \"def randomize_trajectory(self):\\n self.angle = randint(-360, 360)\\n self.speed = randint(1, 5)/2.5\",\n \"def mutate_random(self, point, population):\\n other = Point(self.model.generate())\\n other.evaluate(self.model)\\n while other in population or other == point:\\n other = Point(self.model.generate())\\n other.evaluate(self.model)\\n return other\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def time_per_part():\\r\\n return random.normalvariate(PT_MEAN, PT_SIGMA)\",\n \"def rand(self, x):\\r\\n return np.random.random(1)[0]\",\n \"def create_random_points(n):\\n\\n\\treturn [(random.randint(0,n),random.randint(0,n)) for i in range(n)]\",\n \"def plot_jitter(jitter_ax, col_counter,\\r\\n wt_x_vals,\\r\\n wt_self_row_medians,\\r\\n mt_self_row_medians,\\r\\n wt_mut_row_medians,\\r\\n# null_x_vals,\\r\\n# null_conn,\\r\\n wt_mut_rep_pval_text,\\r\\n wt_vs_mut_wt_conn_pval_text,\\r\\n use_c_pval,\\r\\n ymin, ymax,\\r\\n corr_val_str):\\r\\n x_vals = []\\r\\n y_vals = []\\r\\n for i in range(len(wt_self_row_medians)):\\r\\n y_vals.append(wt_self_row_medians[i])\\r\\n x_vals.append(wt_x_vals[i])\\r\\n for val in mt_self_row_medians:\\r\\n y_vals.append(val)\\r\\n x_vals.append(random.randint(MUT_RANGE[0], MUT_RANGE[1]))\\r\\n for val in wt_mut_row_medians:\\r\\n y_vals.append(val)\\r\\n x_vals.append(random.randint(CONN_RANGE[0], CONN_RANGE[1]))\\r\\n# for i in range(len(null_conn)):\\r\\n# y_vals.append(null_conn[i])\\r\\n# x_vals.append(null_x_vals[i])\\r\\n\\r\\n jitter_ax.plot(x_vals, y_vals,\\r\\n 'k.',\\r\\n c=((0,0,0,0.25)))\\r\\n\\r\\n jitter_ax.set_ylim(ymin,ymax)\\r\\n jitter_ax.set_xlim(0, XMAX)\\r\\n if col_counter == 1:\\r\\n jitter_ax.set_ylabel(corr_val_str)\\r\\n\\r\\n jitter_ax.set_xticks(JITTER_XTICKS)\\r\\n jitter_ax.set_xticklabels([\\\"wt\\\",\\r\\n \\\"mut\\\",\\r\\n \\\"wt-mut\\\",\\r\\n \\\"random\\\"],\\r\\n# rotation=45,\\r\\n# ha='right',\\r\\n size='x-small')\\r\\n\\r\\n # Add p-value text\\r\\n if use_c_pval:\\r\\n pval_type = \\\"cP\\\"\\r\\n else:\\r\\n pval_type = \\\"P\\\"\\r\\n jitter_ax.text(2,\\r\\n ymin/3,\\r\\n \\\"wt_vs_mut_%s:\\\\n\\\" % pval_type + wt_mut_rep_pval_text,\\r\\n size='x-small')\\r\\n\\r\\n jitter_ax.text(XMAX - 2,\\r\\n ymin/3,\\r\\n \\\"wt_vs_conn_%s:\\\\n\\\" % pval_type + wt_vs_mut_wt_conn_pval_text,\\r\\n ha='right',\\r\\n size='x-small')\",\n \"def mutate(self, size):\\n rand = random.random()\\n if rand <= 0.5:\\n print u\\\"changing colour\\\"\\n idx = random.randrange(0, 4)\\n value = random.randrange(0, 256)\\n colour = list(self.colour)\\n colour[idx] = value\\n self.colour = tuple(colour)\\n else:\\n print u\\\"changing point\\\"\\n idx = random.randrange(0, len(self.points))\\n point = generate_point(size[0], size[1])\\n self.points[idx] = point\",\n \"def increment_point(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-2))\\n seed = random.randint(0,2)\\n if seed == 0:\\n point_index2 = point_index1 + 1\\n elif seed == 1:\\n point_index2 = random.randint(point_index1,max(0,len(mutated_genome[index][2])-1))\\n else: #seed == 2:\\n point_index2 = max(0,len(mutated_genome[index][2])-1)\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def totem_random():\\n random_head()\\n random_head()\\n random_head()\",\n \"def random():\\r\\n return R.NextDouble()\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def random_transform(self, x):\\n pass\",\n \"def perturb_point(self, x, scale):\\n x_samp = x + (scale / 2.0) * (np.random.rand(3) - 0.5)\\n return x_samp\",\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def RandomDelay():\\r\\n sleep(random())\",\n \"def jitter_under_thresh(x: xr.DataArray, thresh: float):\\n epsilon = np.finfo(x.dtype).eps\\n if uses_dask(x):\\n jitter = dsk.random.uniform(\\n low=epsilon, high=thresh, size=x.shape, chunks=x.chunks\\n )\\n else:\\n jitter = np.random.uniform(low=epsilon, high=thresh, size=x.shape)\\n return x.where(~((x < thresh) & (x.notnull())), jitter.astype(x.dtype))\",\n \"def generate(random, lower, upper, count=1):\\n if count > 1:\\n points = []\\n\\n for x in range(lower.x, upper.x):\\n for y in range(lower.y, upper.y):\\n points.append(Point(x, y)) # REFACTOR: Not very efficient\\n\\n return random.sample(points, count)\\n else:\\n return Point(random.randrange(lower.x, upper.x), random.randrange(lower.y, upper.y))\",\n \"def RandomCoordinate(): \\r\\n return ReturnRounded(np.random.uniform(-10,10))\",\n \"def randomizeDelays(self, rand_distr):\\n raise NotImplementedError\",\n \"def rand_djitter(arr):\\n stdev = 0.005\\n return arr + (-1+2*np.random.random(len(arr)))*stdev\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def random_transform(self, x, seed=None):\\n # x is a single audio, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\\n input_length = x.shape[img_row_axis]\\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\\n if x.shape[img_row_axis] >= input_length:\\n x = x[:input_length]\\n else:\\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\\n 'constant', constant_values=(0, np.mean(x)))\\n\\n if shift:\\n hx = np.random.uniform(-self.shift, self.shift)\\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\\n\\n if self.roll_range:\\n tx = np.random.uniform(-self.roll_range, self.roll_range)\\n if self.roll_range < 1:\\n tx *= x.shape[img_row_axis]\\n x = np.roll(x, int(tx), axis=(img_row_axis))\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = np.flip(x, axis=img_row_axis)\\n\\n if (self.noise):\\n if np.random.random() < 0.5:\\n if self.noise[-1] == 'Uniform':\\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\\n elif self.noise[-1] == 'Normal':\\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\\n\\n if self.brightness_range is not None:\\n x = random_brightness(x, self.brightness_range)\\n\\n return x\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def noise_data(self, x):\\n return x + np.random.normal(size=x.shape)\",\n \"def random_point(self, n_samples=1):\\n vertices = self.ambient_manifold.random_point(n_samples * self.n_vertices)\\n vertices = gs.reshape(vertices, (n_samples, self.n_vertices, 3))\\n return vertices[0] if n_samples == 1 else vertices\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:,idx,:]\",\n \"def shift_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def Randomize(seed=None):\\n random.seed()\",\n \"def cell_sample(mask, samplingPoints):\\n maskedArea = np.array(np.where(mask)).T\\n maskedAreaLength = len(maskedArea)\\n randomIndex = sp.random.randint(0, maskedAreaLength, samplingPoints)\\n coordsRandom = maskedArea[randomIndex] + sp.rand(samplingPoints, 2)\\n return(coordsRandom)\",\n \"def samplepoint(x,u):\\n return point(x)\",\n \"def __randomize_data(self):\\n times = map(lambda (t, _): t, self.data)\\n coords = map(lambda (_, c): c, self.data)\\n return zip(times, map(DataGen.__randomize_coord, coords))\",\n \"def changeState(self, xyPoints):\\n nPts = len(xyPoints)\\n ind0 = random.randint(1, nPts-1)\\n ind1 = random.randint(1, nPts-1)\\n while ind1 == ind0:\\n ind1 = random.randint(1, nPts-1)\\n # make copy of the sources to make sure the swap works correctly\\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])\",\n \"def pick_poisson_random_points(points, pick_number, lam):\\n random = np.random.default_rng()\\n\\n random_picks = []\\n\\n while len(random_picks) < pick_number:\\n random_num = random.poisson(lam) # picks poisson random number\\n if not random_num in random_picks and 0 < random_num < len(\\n points): # Checks to make sure number hasnt been picked yet and is within range\\n random_picks.append(random_num)\\n new_map = {}\\n for i in random_picks: # assigns and copies picked points into a new dictionary\\n new_map[i] = Point(i, points.get(i).get_actual_pollution_value(), points.get(i).get_x_cord())\\n new_map.get(i).read_pollution_value()\\n\\n return new_map\",\n \"def gen_lat_lon(self):\\n delta = round(random.random() * random.randint(1, 4), 4)\\n sign = random.randint(1, 100)\\n if sign % 2 == 0:\\n self.lat += delta\\n else:\\n self.lat -= delta\\n\\n delta = round(random.random() * random.randint(1, 4), 4)\\n sign = random.randint(1, 100)\\n if sign % 2 == 0:\\n self.lon += delta\\n else:\\n self.lon -= delta\",\n \"def random_temp():\\n temp_min = 154\\n temp_max = 500\\n temp_interval = 1\\n # `range`s are exclusive [min, max)\\n return random.randrange(temp_min, temp_max + 1, temp_interval)\",\n \"def reroll(self):\\n self._base_x = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._x_min,\\n self.base_point_distribution._x_max\\n )\\n self._base_y = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._y_min,\\n self.base_point_distribution._y_max\\n )\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def random(self, n=1):\\n # self.num_generated += n\",\n \"def noise(x: np.ndarray) -> np.ndarray:\\n\\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)\",\n \"def scatter_points(n):\\r\\n P1 = np.random.randn(int(np.ceil(n/2)), 2) - 4\\r\\n P2 = 3 * np.random.rand(int(np.ceil(n/4)), 2) - np.array([10, 0])\\r\\n P3 = np.random.randn(int(np.ceil(n/4)), 2) + 3\\r\\n \\\"\\\"\\\"\\r\\n P1=np.floor(P1)\\r\\n P2=np.floor(P2)\\r\\n P3=np.floor(P3)\\r\\n \\\"\\\"\\\"\\r\\n L = list(np.concatenate((P1,P2,P3), axis=0))\\r\\n \\r\\n return L \\r\\n #return no_dupli(L)\\r\",\n \"def rnd_pset(self):\\n\\t\\treturn [rnd() * 10, rnd() * 10, rnd() * 12 * 15, rnd() * 12 * 15]\",\n \"def salt_and_pepper_noise(image, prob):\\n output = np.zeros(image.shape,np.uint8)\\n thres = 1 - prob \\n for i in range(image.shape[0]):\\n for j in range(image.shape[1]):\\n rdn = random.random()\\n if rdn < prob:\\n output[i][j] = 0\\n elif rdn > thres:\\n output[i][j] = 255\\n else:\\n output[i][j] = image[i][j]\\n return output\",\n \"def add_salt_pepper_noise(img):\\n # Need to produce a copy as to not modify the original image\\n dice = random.randint(0, 100)\\n\\n if (dice < 30):\\n row, col, _ = img.shape\\n salt_vs_pepper = 0.20\\n amount = 0.030\\n num_salt = np.ceil(amount * img.size * salt_vs_pepper)\\n num_pepper = np.ceil(amount * img.size * (1.0 - salt_vs_pepper))\\n\\n # Add Salt noise\\n coords = [np.random.randint(0, i - 1, int(num_salt)) for i in img.shape]\\n img[coords[0], coords[1], :] = 255\\n\\n # Add Pepper noise\\n coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in img.shape]\\n img[coords[0], coords[1], :] = 0\\n return img\",\n \"def add_uniform_noise(data, p=1):\\n if p < 1:\\n raise ValueError(\\\"'p' has to be greater or equal to 1.\\\")\\n noise = np.random.uniform(-5.*10**(-p), 5*10**(-p), size = len(data))\\n randomized_data = data + noise\\n # ensure there are no negative entries after noise is added\\n randomized_data = \\\\\\n randomized_data[np.where(randomized_data > 0)]\\n return randomized_data\",\n \"def sample_using_point_estimate(self, x:float, x_std:float, k, name, delay, lagged_values, lagged_times):\\n return normal_sample_projected(prediction_std=x, prediction_mean=x_std,\\n num=self.num_predictions, lagged_values=lagged_values)\",\n \"def random_float():\\n return (random() - 0.5) * 2\",\n \"def pickup_samples(pts1, pts2):\\n\\n #\\n # Your code here\\n #\\n\\n x = min(len(pts1), len(pts2))\\n return np.random.choice(range(x), min_num_pairs(), replace=False)\",\n \"def MovePoint(pos,points,s=0.5, k = 1000): \\n \\n x = [pos[0]] \\n y = [pos[1]]\\n rdm.seed(1) # comment out if you want randomness\\n for i in range(k):\\n n = len(points)\\n r = int(rdm.random()*n)\\n \\n x.append(x[i] + (points[r][0] - x[i]) * s)\\n y.append(y[i] + (points[r][1] - y[i]) * s)\\n\\n \\n return(x,y)\",\n \"def ternary_noise(N_stimuli, Nx, Ny):\\n return np.random.randint(-1, 2, size=(N_stimuli, Nx, Ny))\",\n \"def random_position():\\n path = (\\n os.path.dirname(__file__)\\n + os.sep\\n + \\\"templates\\\"\\n + os.sep\\n + \\\"data\\\"\\n + os.sep\\n + \\\"taxi_stations.json\\\"\\n )\\n with open(path) as f:\\n stations = json.load(f)[\\\"features\\\"]\\n pos = random.choice(stations)\\n coords = [pos[\\\"geometry\\\"][\\\"coordinates\\\"][1], pos[\\\"geometry\\\"][\\\"coordinates\\\"][0]]\\n lat = float(\\\"{0:.6f}\\\".format(coords[0]))\\n lng = float(\\\"{0:.6f}\\\".format(coords[1]))\\n return [lat, lng]\",\n \"def rand_coord(n):\\n\\n x = random.randint(0, n - 1)\\n y = random.randint(0, n - 1)\\n return x, y\",\n \"def _randomVelocity(self):\\n\\t\\treturn random.choice([-1, 1]) * random.randint(10, 50)\",\n \"def random_importance_function():\\n return random()\",\n \"def generate_random_point_in_domain(self, random_source=None):\\n return numpy.array([self._domain.generate_random_point_in_domain(random_source=random_source)\\n for _ in xrange(self.num_repeats)])\",\n \"def data_feeder_2():\\n return random.sample(range(100), 10)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73470956","0.72041214","0.71101594","0.70101404","0.67910165","0.6369184","0.6235321","0.6233606","0.6164337","0.6122401","0.6082923","0.6006233","0.5953184","0.595242","0.5943489","0.59328365","0.5924084","0.5902909","0.5856639","0.58350176","0.5834869","0.58062315","0.580246","0.5765416","0.57632947","0.5728251","0.57106113","0.5690125","0.56877977","0.5640001","0.5639049","0.5636212","0.5636212","0.5636212","0.5626301","0.56096834","0.55895054","0.5582602","0.55789804","0.55727506","0.55677885","0.5564487","0.5540471","0.552387","0.5523825","0.5515988","0.55122083","0.55070955","0.5494343","0.5469079","0.54675096","0.5464499","0.54634804","0.54603636","0.5448492","0.5447117","0.54468","0.5443218","0.5439649","0.5437125","0.5434801","0.5432329","0.54320174","0.54153883","0.54119384","0.54082644","0.54016364","0.53836435","0.53747594","0.5372844","0.5370987","0.53693175","0.53604394","0.53594166","0.5352001","0.5347144","0.5341326","0.5337454","0.5336553","0.53339773","0.53336304","0.5332552","0.5320723","0.5319568","0.5316689","0.5316656","0.5313149","0.529502","0.5293678","0.5287887","0.5273704","0.527308","0.5271209","0.5269333","0.52669346","0.52652574","0.52599084","0.5258324"],"string":"[\n \"0.73470956\",\n \"0.72041214\",\n \"0.71101594\",\n \"0.70101404\",\n \"0.67910165\",\n \"0.6369184\",\n \"0.6235321\",\n \"0.6233606\",\n \"0.6164337\",\n \"0.6122401\",\n \"0.6082923\",\n \"0.6006233\",\n \"0.5953184\",\n \"0.595242\",\n \"0.5943489\",\n \"0.59328365\",\n \"0.5924084\",\n \"0.5902909\",\n \"0.5856639\",\n \"0.58350176\",\n \"0.5834869\",\n \"0.58062315\",\n \"0.580246\",\n \"0.5765416\",\n \"0.57632947\",\n \"0.5728251\",\n \"0.57106113\",\n \"0.5690125\",\n \"0.56877977\",\n \"0.5640001\",\n \"0.5639049\",\n \"0.5636212\",\n \"0.5636212\",\n \"0.5636212\",\n \"0.5626301\",\n \"0.56096834\",\n \"0.55895054\",\n \"0.5582602\",\n \"0.55789804\",\n \"0.55727506\",\n \"0.55677885\",\n \"0.5564487\",\n \"0.5540471\",\n \"0.552387\",\n \"0.5523825\",\n \"0.5515988\",\n \"0.55122083\",\n \"0.55070955\",\n \"0.5494343\",\n \"0.5469079\",\n \"0.54675096\",\n \"0.5464499\",\n \"0.54634804\",\n \"0.54603636\",\n \"0.5448492\",\n \"0.5447117\",\n \"0.54468\",\n \"0.5443218\",\n \"0.5439649\",\n \"0.5437125\",\n \"0.5434801\",\n \"0.5432329\",\n \"0.54320174\",\n \"0.54153883\",\n \"0.54119384\",\n \"0.54082644\",\n \"0.54016364\",\n \"0.53836435\",\n \"0.53747594\",\n \"0.5372844\",\n \"0.5370987\",\n \"0.53693175\",\n \"0.53604394\",\n \"0.53594166\",\n \"0.5352001\",\n \"0.5347144\",\n \"0.5341326\",\n \"0.5337454\",\n \"0.5336553\",\n \"0.53339773\",\n \"0.53336304\",\n \"0.5332552\",\n \"0.5320723\",\n \"0.5319568\",\n \"0.5316689\",\n \"0.5316656\",\n \"0.5313149\",\n \"0.529502\",\n \"0.5293678\",\n \"0.5287887\",\n \"0.5273704\",\n \"0.527308\",\n \"0.5271209\",\n \"0.5269333\",\n \"0.52669346\",\n \"0.52652574\",\n \"0.52599084\",\n \"0.5258324\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5786313"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":9470,"cells":{"query":{"kind":"string","value":"Randomly shift point cloud. Shift is per point cloud."},"document":{"kind":"string","value":"def shift_point_cloud(batch_data, shift_range=0.1):\n B, N, C = batch_data.shape\n shifts = np.random.uniform(-shift_range, shift_range, (B,3))\n for batch_index in range(B):\n batch_data[batch_index,:,:] += shifts[batch_index,:]\n return batch_data"},"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 shift(self):\n \"\"\"\n shift cluster randomly within bounds of im\n \"\"\"\n r = self.std\n mid = self.mid_pixel #center pixel index of 384x384 image\n delta = self.im_size - self.mid_pixel - r - 10\n \n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n\n self.x += x\n self.y += y\n im_shift = np.roll(self.im,shift=y,axis=0)\n self.im = np.roll(im_shift,shift=x,axis=1)\n \n return","def shift_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def shift(self):\n r = self.std\n mid = self.mid_pixel #center pixel index of 384x384 image\n delta = self.size - self.mid_pixel - r\n \n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\n\n self.x += x\n self.y += y\n image_shift = np.roll(self.image,shift=x,axis=0)\n self.image = np.roll(image_shift,shift=y,axis=1)\n \n return","def mutate_point_trig(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_trig(mutated_genome,index)\n else: #seed == 1:\n shift_point_trig(mutated_genome,index)","def shift_point_wline(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(1,max(1,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])","def switch_points(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def shift_point_trig(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n triangle = mutated_genome[index][2]\n seed = random.randint(0,2)\n oldpoint = triangle[seed]\n newpoint = (oldpoint+Xval, newpoint+Yval)\n newtriangle = list(triangle)\n newtriangle[seed] = newpoint\n mutated_genome[index][2] = tuple(newtriangle)","def random_transform(self, x, seed=None):\n # x is a single audio, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\n input_length = x.shape[img_row_axis]\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\n if x.shape[img_row_axis] >= input_length:\n x = x[:input_length]\n else:\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\n 'constant', constant_values=(0, np.mean(x)))\n\n if shift:\n hx = np.random.uniform(-self.shift, self.shift)\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\n\n if self.roll_range:\n tx = np.random.uniform(-self.roll_range, self.roll_range)\n if self.roll_range < 1:\n tx *= x.shape[img_row_axis]\n x = np.roll(x, int(tx), axis=(img_row_axis))\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = np.flip(x, axis=img_row_axis)\n\n if (self.noise):\n if np.random.random() < 0.5:\n if self.noise[-1] == 'Uniform':\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\n elif self.noise[-1] == 'Normal':\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\n\n if self.brightness_range is not None:\n x = random_brightness(x, self.brightness_range)\n\n return x","def move_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\n point = (Xval,Yval)\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n mutated_genome[index][2][point_index] = point","def MovePoint(pos,points,s=0.5, k = 1000): \n \n x = [pos[0]] \n y = [pos[1]]\n rdm.seed(1) # comment out if you want randomness\n for i in range(k):\n n = len(points)\n r = int(rdm.random()*n)\n \n x.append(x[i] + (points[r][0] - x[i]) * s)\n y.append(y[i] + (points[r][1] - y[i]) * s)\n\n \n return(x,y)","def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\n if random.random() < move_prob:\n pass\n else:\n self.epislon = old_epislon","def decrement_point(mutated_genome,index):\n point_index1 = random.randint(1,max(0,len(mutated_genome[index][2])-1))\n seed = random.randint(0,2)\n if seed == 0:\n point_index2 = point_index1 - 1\n elif seed == 1:\n point_index2 = random.randint(0, point_index1)\n else: #seed == 2:\n point_index2 = 0\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def mutate_point_circ(mutated_genome):\n seed = random.randint(0,3)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_circ(mutated_genome,index)\n elif seed == 1:\n shift_point_circ(mutated_genome,index)\n elif seed == 2:\n move_radius_circ(mutated_genome,index)\n else: #seed == 3:\n shift_radius_circ(mutated_genome,index)","def random_shift(x, fraction):\n min_x, max_x = np.min(x), np.max(x)\n m = np.random.uniform(-fraction, fraction, size=x.shape) + 1\n return np.clip(x * m, min_x, max_x)","def rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def mutate_point_poly3(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]","def random_transform_extension(self, x, y, seed=None):\n # x is a single image, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n # use composition of homographies\n # to generate final transform that needs to be applied\n if self.rotation_range:\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(-self.shear_range, self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\n\n transform_matrix = None\n if theta != 0:\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n transform_matrix = rotation_matrix\n\n if tx != 0 or ty != 0:\n shift_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\n\n if shear != 0:\n shear_matrix = np.array([[1, -np.sin(shear), 0],\n [0, np.cos(shear), 0],\n [0, 0, 1]])\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\n\n if zx != 1 or zy != 1:\n zoom_matrix = np.array([[zx, 0, 0],\n [0, zy, 0],\n [0, 0, 1]])\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\n\n if transform_matrix is not None:\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n if self.channel_shift_range != 0:\n x = image.random_channel_shift(x,\n self.channel_shift_range,\n img_channel_axis)\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_col_axis)\n y = kimage.flip_axis(y, img_col_axis)\n\n if self.vertical_flip:\n if np.random.random() < 0.5:\n x = kimage.flip_axis(x, img_row_axis)\n y = kimage.flip_axis(y, img_row_axis)\n return x, y","def mutate_point_rect(mutated_genome):\n seed = random.randint(0,1)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if seed == 0:\n move_point_rect(mutated_genome,index)\n else: #seed == 1:\n shift_point_rect(mutated_genome,index)","def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:,idx,:]","def increment_point(mutated_genome,index):\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-2))\n seed = random.randint(0,2)\n if seed == 0:\n point_index2 = point_index1 + 1\n elif seed == 1:\n point_index2 = random.randint(point_index1,max(0,len(mutated_genome[index][2])-1))\n else: #seed == 2:\n point_index2 = max(0,len(mutated_genome[index][2])-1)\n temp = mutated_genome[index][2][point_index1]\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\n mutated_genome[index][2][point_index2] = temp","def MoveRandom(self):\n r = random.randint(0,3)\n if r == 0: self.x += 1\n elif r == 1: self.y += 1\n elif r == 2: self.x -= 1\n elif r == 3: self.y -= 1","def move_point_trig(mutated_genome,index):\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\n point = (Xval,Yval)\n old_points = list(mutated_genome[index][2])\n old_points[random.randint(0,2)] = point\n mutated_genome[index][2] = tuple(old_points)","def random_rotate(self):\r\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\r\n flip = rand.randrange(0, 2, 1) # 0, 1\r\n new_seed = copy.deepcopy(self)\r\n # rotate by 90 degrees * rotation (0, 90, 180 270)\r\n new_seed.cells = np.rot90(new_seed.cells, rotation) \r\n if (flip == 1):\r\n # flip upside down\r\n new_seed.cells = np.flipud(new_seed.cells)\r\n new_seed.xspan = new_seed.cells.shape[0]\r\n new_seed.yspan = new_seed.cells.shape[1]\r\n return new_seed","def random_transform(self, x):\n pass","def rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def random_shift(x, wrg, hrg, row_axis=0, col_axis=1, channel_axis=2,\n fill_mode='nearest', cval=0., interpolation_order=1):\n h, w = x.shape[row_axis], x.shape[col_axis]\n tx = np.random.uniform(-hrg, hrg) * h\n ty = np.random.uniform(-wrg, wrg) * w\n x = apply_affine_transform(x, tx=tx, ty=ty, channel_axis=channel_axis,\n fill_mode=fill_mode, cval=cval,\n order=interpolation_order)\n return x","def test_shift_point(self):\n point = (0,0)\n new_point = utils.shift_point(point, 3, 4)\n self.assertEqual((3,4), new_point)\n\n point = (-2.34, 1.19)\n new_point = utils.shift_point(point, 2.34, -1.19)\n self.assertEqual((0,0), new_point)","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def augment_cloud(Ps):\n \"Augmented params:\"\n pc_augm_scale=0\n pc_augm_rot=1\n pc_augm_mirror_prob=0.5\n pc_augm_jitter=0\n\n M = transforms3d.zooms.zfdir2mat(1)\n if pc_augm_scale > 1:\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\n if pc_augm_rot:\n angle = random.uniform(0, 2*math.pi)\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\n if random.random() < pc_augm_mirror_prob/2:\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\n result = []\n for P in Ps:\n P[:,:3] = np.dot(P[:,:3], M.T)\n\n if pc_augm_jitter:\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\n result.append(P)\n return result","def mutate_point_wline(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 1: seed = 0\n if seed == 0:\n insert_point_wline(mutated_genome,index)\n elif seed == 1:\n remove_point_wline(mutated_genome,index)\n elif seed == 2:\n switch_points_wline(mutated_genome,index)\n elif seed == 3:\n shuffle_points_wline(mutated_genome,index)\n elif seed == 4:\n move_point_wline(mutated_genome,index)\n elif seed == 5:\n shift_point_wline(mutated_genome,index)\n elif seed == 6:\n increment_point_wline(mutated_genome,index)\n else: #seed == 7:\n decrement_point_wline(mutated_genome,index)","def _sample_k_new(self, cur_y, cur_z):\n N = float(len(self.obs))\n #old_loglik = self._loglik(cur_y, cur_z)\n\n k_new_count = np.random.poisson(self.alpha / N)\n if k_new_count == 0: return False\n \n # modify the feature ownership matrix\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\n # propose feature images by sampling from the prior distribution\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\n \n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)","def mutate_point_poly(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 3: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def resample_particles(self):\n # make sure the distribution is normalized\n self.normalize_particles()\n\n newParticles = []\n for i in range(len(self.particle_cloud)):\n # resample the same # of particles\n choice = random_sample()\n # all the particle weights sum to 1\n csum = 0 # cumulative sum\n for particle in self.particle_cloud:\n csum += particle.w\n if csum >= choice:\n # if the random choice fell within the particle's weight\n newParticles.append(deepcopy(particle))\n break\n self.particle_cloud = newParticles","def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\r\n B, N, C = batch_data.shape\r\n assert(clip > 0)\r\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\r\n jittered_data += batch_data\r\n return jittered_data","def randomShiftVector(values, smin, smax):\n\tshift = np.random.uniform(smin, smax)\n\treturn list(map(lambda va: va + shift, values))","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def crossover(new_pop, k):\n shuffle(new_pop)\n for i in range(len(new_pop) // 2):\n points = random.sample(range(1, len(new_pop[i])), k)\n points.sort()\n for fold in range(k):\n x = points[fold]\n tmp = new_pop[2 * i][:x].copy()\n new_pop[2 * i][:x], new_pop[2 * i + 1][:x] = new_pop[2 * i +\n 1][:x], tmp\n return new_pop","def random_shift(x, wrg, hrg, row_axis=1, col_axis=2, channel_axis=0,\n fill_mode='nearest', cval=0.):\n h, w = x.shape[row_axis], x.shape[col_axis]\n tx = np.random.uniform(-hrg, hrg) * h\n ty = np.random.uniform(-wrg, wrg) * w\n translation_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n\n transform_matrix = translation_matrix # no need to do offset\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\n return x","def lift(point):\n return gs.copy(point)","def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data","def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data","def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data","def _get_random_transform(self, img_shape, seed=None):\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if self.rotation_range:\n theta = np.random.uniform(\n -self.rotation_range,\n self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n try: # 1-D array-like or int\n tx = np.random.choice(self.height_shift_range)\n tx *= np.random.choice([-1, 1])\n except ValueError: # floating point\n tx = np.random.uniform(-self.height_shift_range,\n self.height_shift_range)\n if np.max(self.height_shift_range) < 1:\n tx *= img_shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n try: # 1-D array-like or int\n ty = np.random.choice(self.width_shift_range)\n ty *= np.random.choice([-1, 1])\n except ValueError: # floating point\n ty = np.random.uniform(-self.width_shift_range,\n self.width_shift_range)\n if np.max(self.width_shift_range) < 1:\n ty *= img_shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(\n -self.shear_range,\n self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(\n self.zoom_range[0],\n self.zoom_range[1],\n 2)\n\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\n\n channel_shift_intensity = None\n if self.channel_shift_range != 0:\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\n self.channel_shift_range)\n\n brightness = None\n if self.brightness_range is not None:\n brightness = np.random.uniform(self.brightness_range[0],\n self.brightness_range[1])\n\n transform_parameters = {'theta': theta,\n 'tx': tx,\n 'ty': ty,\n 'shear': shear,\n 'zx': zx,\n 'zy': zy,\n 'flip_horizontal': flip_horizontal,\n 'flip_vertical': flip_vertical,\n 'channel_shift_intensity': channel_shift_intensity,\n 'brightness': brightness}\n\n return transform_parameters","def jitter_point_cloud(batch_data, sigma=0.02, clip=0.05):\n B, N, C = batch_data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += batch_data\n return jittered_data","def shift_augmentation():\n shift = np.random.randint(-200, 201, size=2)\n return lambda image: shift_with_extension(image, shift)","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def repick(g1_x, g1_y, g1_z):\n i = random.randint(0, len(g1_x) - 1)\n x = g1_x[i]\n y = g1_y[i]\n z = g1_z[i]\n return x, y, z","def random_scale_point_cloud(batch_data, scale_low=0.8, scale_high=1.25):\n B, N, C = batch_data.shape\n scales = np.random.uniform(scale_low, scale_high, B)\n for batch_index in range(B):\n batch_data[batch_index,:,:] *= scales[batch_index]\n return batch_data","def move_point_wline(mutated_genome,index):\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\n point = (Xval,Yval)\n point_index = random.randint(1,max(1,len(mutated_genome[index][2])-1))\n mutated_genome[index][2][point_index] = point","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def shift_point_circ(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n circle = mutated_genome[index][2]\n newcircle = (circle[0]+Xval,circle[1]+Yval,circle[2])\n mutated_genome[index][2] = newcircle","def random_shift(image, wsr=0.1, hsr=0.1):\n height, width, _ = common_layers.shape_list(image)\n width_range, height_range = wsr*width, hsr*height\n height_translations = tf.random_uniform((1,), -height_range, height_range)\n width_translations = tf.random_uniform((1,), -width_range, width_range)\n translations = tf.concat((height_translations, width_translations), axis=0)\n return tf.contrib.image.translate(image, translations=translations)","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def random_shift(self, X, y_2d, im_h, im_w, scale):\n wrng = np.random.randint(-int(im_w*scale), int(im_w*scale))\n hrng = np.random.randint(-int(im_h*scale), int(im_h*scale))\n\n X = self.shift_im(X, wrng)\n X = self.shift_im(X, hrng, dim=1)\n\n y_2d = self.shift_im(y_2d, wrng)\n y_2d = self.shift_im(y_2d, hrng, dim=1)\n\n return X, y_2d","def generate_shift(self, k=1, static=False):\n if static:\n shift = np.zeros((k, 2))\n else:\n shift = np.array(self.environment_size)/2 * np.random.rand(k, 2) - np.array(self.environment_size)/4\n return shift","def generate_shift(self, k=1, static=False):\n if static:\n shift = np.zeros((k, 2))\n else:\n shift = np.array(self.environment_size)/2 * np.random.rand(k, 2) - np.array(self.environment_size)/4\n return shift","def move(self):\n if self._z >= 75:\n a = random.random()\n print(str(a))\n if a < 0.2:\n self._z += 1\n if a > 0.2 and a < 0.9:\n self._z -= 1\n if a > 0.9:\n self._z = self._z\n else: \n self._z -= 1\n \n b = random.random()\n print(str(b))\n if b < 0.1:\n self._y += 1\n if b > 0.1 and b < 0.2:\n self._y -= 1\n if b > 0.2 and b < 0.25:\n self._x -= 1\n if b > 0.25:\n self._x += 1","def shuffle_points(data):\n idx = np.arange(data.shape[1])\n np.random.shuffle(idx)\n return data[:, idx, :], idx","def random_channel_swap(self, img, p = 0.5):\n if self.decision(p):\n img[:, :, 0], img[:, :, 1] = img[:, :, 1], img[:, :, 0]\n if self.decision(p):\n img[:, :, 1], img[:, :, 2] = img[:, :, 2], img[:, :, 1]\n if self.decision(p):\n img[:, :, 2], img[:, :, 0] = img[:, :, 0], img[:, :, 2]\n return img","def augmenter(x, y):\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\n # as 3D microscopy acquisitions are usually not axially symmetric\n x, y = random_fliprot(x, y, axis=(1, 2))\n x = random_intensity_change(x)\n return x, y","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def shuffle(self):\n self.__c_elem().melange()","def jitter_point_cloud(data, sigma=0.25, clip=1):\n B, N, C = data.shape\n assert(clip > 0)\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\n jittered_data += data\n return jittered_data","def captureNewDataPoint(self):\n return 2.0*rand()-1.0","def _permute_sign(data, seed, return_stat=\"mean\"):\n\n random_state = np.random.RandomState(seed)\n new_dat = data * random_state.choice([1, -1], len(data))\n if return_stat == \"ceof\":\n return np.mean(new_dat)\n elif return_stat == \"t-stat\":\n return np.mean(new_dat) / (np.std(new_dat, ddof=1) / np.sqrt(len(new_dat)))","def sample(self):\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\n x = self.x_prev\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\n self.dt\n ) * np.random.normal(size=self.mu.shape)\n self.x_prev = x + dx\n return self.x_prev","def shuffle(self): \n for x in range(12):\n self.right(primary=-60, counter=0)\n time.sleep(.1)\n self.left(primary=-60, counter=0)\n time.sleep(.1)\n self.stop()","def random_transform(self, x_batch):\n # x is a single image, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_col_axis = self.col_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n rt_batch = np.zeros_like(x_batch)\n for i in xrange(x_batch.shape[0]):\n x = x_batch[i]\n\n # use composition of homographies\n # to generate final transform that needs to be applied\n if self.rotation_range:\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\n else:\n theta = 0\n\n if self.height_shift_range:\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\n else:\n tx = 0\n\n if self.width_shift_range:\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\n else:\n ty = 0\n\n if self.shear_range:\n shear = np.random.uniform(-self.shear_range, self.shear_range)\n else:\n shear = 0\n\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\n\n transform_matrix = None\n if theta != 0:\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n transform_matrix = rotation_matrix\n\n if tx != 0 or ty != 0:\n shift_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\n\n if shear != 0:\n shear_matrix = np.array([[1, -np.sin(shear), 0],\n [0, np.cos(shear), 0],\n [0, 0, 1]])\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\n\n if zx != 1 or zy != 1:\n zoom_matrix = np.array([[zx, 0, 0],\n [0, zy, 0],\n [0, 0, 1]])\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\n\n if transform_matrix is not None:\n h, w = x.shape[img_row_axis], x.shape[img_col_axis]\n transform_matrix = transform_matrix_offset_center(transform_matrix, h, w)\n x = apply_transform(x, transform_matrix, img_channel_axis,\n fill_mode=self.fill_mode, cval=self.cval)\n\n if self.channel_shift_range != 0:\n x = random_channel_shift(x,\n self.channel_shift_range,\n img_channel_axis)\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = flip_axis(x, img_col_axis)\n\n if self.vertical_flip:\n if np.random.random() < 0.5:\n x = flip_axis(x, img_row_axis)\n\n if self.random_curves_strength > 0.:\n x = random_curves_transform(x,self.random_curves_strength)\n\n rt_batch[i] = x\n\n return rt_batch","def shuffle(self):\r\n #\r\n shuffled_seed = copy.deepcopy(self)\r\n #\r\n # for each location [x0][y0], randomly choose another location\r\n # [x1][y1] and swap the values of the cells in the two locations.\r\n #\r\n for x0 in range(self.xspan):\r\n for y0 in range(self.yspan):\r\n x1 = rand.randrange(self.xspan)\r\n y1 = rand.randrange(self.yspan)\r\n temp = shuffled_seed.cells[x0][y0]\r\n shuffled_seed.cells[x0][y0] = shuffled_seed.cells[x1][y1]\r\n shuffled_seed.cells[x1][y1] = temp\r\n #\r\n return shuffled_seed","def shift_point_rect(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n rectangle = mutated_genome[index][2]\n seed = random.randint(0,1)\n oldpoint = rectangle[seed]\n newpoint = (oldpoint+Xval, newpoint+Yval)\n newrectangle = list(rectangle)\n newrectangle[seed] = newpoint\n mutated_genome[index][2] = tuple(newrectangle)","def next_sample(self, z):\n xp = self.A @ self.x\n Pp = self.A @ self.P @ self.A.T + self.Q\n\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\n\n self.x = xp + self.K @ (z - self.H @ xp)\n self.P = Pp - self.K @ self.H @ Pp\n return self.x","def random_step(self):\n pos = [i for i in range(9) if self.grid[i] == 0]\n move = random.choice(pos)\n return self.step(move)","def random_step(self):\n pos = [i for i in range(9) if self.grid[i] == 0]\n move = random.choice(pos)\n return self.step(move)","def mutate_random(self, point, population):\n other = Point(self.model.generate())\n other.evaluate(self.model)\n while other in population or other == point:\n other = Point(self.model.generate())\n other.evaluate(self.model)\n return other","def shift_shuffle(self, continuum: Continuum) -> None:\n shift_max = self.magnitude * self.SHIFT_FACTOR * \\\n self._reference_continuum.avg_length_unit\n for annotator in continuum.annotators:\n for unit in continuum[annotator]:\n continuum.remove(annotator, unit)\n start_seg, end_seg = 0.0, 0.0\n while start_seg >= end_seg:\n start_seg = unit.segment.start + np.random.uniform(-1, 1) * shift_max\n end_seg = unit.segment.end + np.random.uniform(-1, 1) * shift_max\n continuum.add(annotator, Segment(start_seg, end_seg), unit.annotation)","def changeState(self, xyPoints):\n nPts = len(xyPoints)\n ind0 = random.randint(1, nPts-1)\n ind1 = random.randint(1, nPts-1)\n while ind1 == ind0:\n ind1 = random.randint(1, nPts-1)\n # make copy of the sources to make sure the swap works correctly\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])","def resample(self):\n self.X = np.random.uniform(-1, 1, (100, 2))\n self.generate_y()\n self.phi = None\n self.K = 0\n self.centers = None\n self.cluster_sizes = None\n self.g = None\n self.gamma = None","def mutate(x, rvs, point=(0,0), insert=(0,0,None), delete=(0,0)):\n data = x.data\n idx = x.indices\n if idx.size==0:\n return x\n n_point = np.random.binomial(point[0], point[1])\n i_point = np.random.choice(x.size, size=n_point, replace=False)\n data[i_point] = rvs(n_point)\n # insertion\n n_insert = np.random.binomial(insert[0], insert[1])\n for _ in range(n_insert):\n while True:\n insert_idx = np.random.choice(insert[2]) if insert[2]\\\n else np.random.choice(x.shape[0])\n if insert_idx not in idx: break\n idx = np.append(idx, insert_idx)\n data = np.append(data, rvs(1))\n # deletion\n n_delete = np.random.binomial(delete[0], delete[1])\n i_delete = np.random.choice(idx.size, size=n_delete, replace=False)\n idx = np.delete(idx, i_delete)\n data = np.delete(data, i_delete)\n y = sp.sparse.csc_matrix((data, (idx, np.zeros(idx.shape, dtype=int))),\n shape=x.shape)\n return y","def __replace_by_noise(self, c):\n n = self.X_train_raw.shape[0]\n temp = []\n for r in xrange(0, n):\n temp.append(self.X_train_raw[r][c])\n shuffle(temp)\n for r in xrange(0, n):\n self.X_train_raw[r][c] = temp[r]","def random(self):\n adj = self.adjacent()\n self.switch(random.choice([pos for pos in adj if self.in_grid(pos) and pos != self.prev]))","def remove_point(mutated_genome,index):\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n del mutated_genome[index][2][point_index]","def move_egg(array):\n new_array = deepcopy(array)\n old_x, old_y = get_random_position(array, 1)\n new_x, new_y = get_random_position(array, 0)\n new_array[old_y][old_x] = 0\n new_array[new_y][new_x] = 1\n return new_array","def move_to_random_pos(self):\n newpos = [(np.random.rand() - 0.5) * 0.1,\n (np.random.rand() - 0.5) * 0.1,\n np.random.rand() * 0.9 + 0.2]\n self.move_to(newpos)","def mc_micro_sweep(self): \n for i in range(self.N):\n if random.random()>0.3:\n self.mc_update_micro_fixed(i,xy = True)","def mutate(self, size):\n rand = random.random()\n if rand <= 0.5:\n print u\"changing colour\"\n idx = random.randrange(0, 4)\n value = random.randrange(0, 256)\n colour = list(self.colour)\n colour[idx] = value\n self.colour = tuple(colour)\n else:\n print u\"changing point\"\n idx = random.randrange(0, len(self.points))\n point = generate_point(size[0], size[1])\n self.points[idx] = point","def _sample_z(self, a):\n r = np.random.rand()\n return ((1 + r * (a - 1))**2) / a","def random_crop(image, steering = 0.0, tx_lower = -20, tx_upper = 20, ty_lower = -2, ty_upper = 2, rand = True):\n\n shape = image.shape\n (col_start, col_end) = (abs(tx_lower), shape[1] - tx_upper)\n horizon = 60\n bonnet = 136\n if rand:\n tx = np.random.randint(tx_lower, tx_upper + 1)\n ty = np.random.randint(ty_lower, ty_upper + 1)\n else:\n (tx, ty) = (0, 0)\n\n crop = image[horizon + ty: bonnet + ty, col_start + tx: col_end + tx, :]\n image = cv2.resize(crop, (320, 160), cv2.INTER_AREA)\n # the steering variable needs to be updated to counteract the shift \n if tx_lower != tx_upper:\n dsteering = -tx / (tx_upper - tx_lower) / 3.0\n else:\n dsteering = 0\n steering += dsteering\n\n return image, steering","def make_temporally_misaligned(x, n_per_spike=1, min_shift='auto',\n max_shift='auto'):\n n_spikes, waveform_length, n_neigh = x.shape\n n_out = int(n_spikes * n_per_spike)\n\n if max_shift == 'auto':\n max_shift = int(0.5 * waveform_length)\n\n if min_shift == 'auto':\n min_shift = int(0.1 * waveform_length)\n\n x_temporally = np.zeros((n_out, waveform_length, n_neigh))\n\n logger.debug('Making spikes with max_shift: %i, output shape: %s',\n max_shift, x_temporally.shape)\n\n for j in range(n_out):\n\n shift = random.choice([-1, 1]) * random.randint(min_shift, max_shift)\n\n idx = np.random.choice(x.shape[0], 1, replace=True)[0]\n spike = x[idx]\n\n if shift > 0:\n x_temporally[j, :(x_temporally.shape[1]-shift)] += spike[shift:]\n\n elif shift < 0:\n x_temporally[\n j, (-shift):] += spike[:(x_temporally.shape[1]+shift)]\n else:\n x_temporally[j] += spike\n\n return x_temporally","def quick_inplace_random(array, left=0, right=None):\n if right is None:\n right = len(array)-1\n if left < right:\n pivot_ind = random.randint(left,right)\n pivot_new_ind = Quick.partition(array, left, right, pivot_ind)\n Quick.quick_inplace_random(array, left, pivot_new_ind-1)\n Quick.quick_inplace_random(array, pivot_new_ind+1, right)","def random():\n np.random.seed(0)","def seed(seed: int):\n # all sampling is actually happening in the move_cube module\n move_cube.seed(seed)","def sample_points(x, n_samples, axis=0, replace=True):\n n_original = x.shape[axis]\n indices = np.random.choice(n_original, n_samples, replace=replace)\n return x.take(indices, axis=axis)","def mutation(self):\n\n for r in range(self.pop_num*3, 5): # Mutation.\n for w in range(0,self.length): \n if random.random()<0.2: \n self.par_and_sons[r].A[w] = self.par_and_sons[r].A[w] + np.random.randint(-20, 20) # Offset + -20 pixels.","def point_random_position(self, point_distribution, mask):\n batch_size = point_distribution.size(0)\n mask_np = to_np(mask) # batch x time\n indices = []\n for i in range(batch_size):\n msk = mask_np[i] # time\n indices.append(np.random.choice(len(msk), 2, p=msk / np.sum(msk, -1)))\n indices = to_pt(np.stack(indices, 0), self.use_cuda) # batch x 2\n return indices","def uniform_redshift(self):\n z_map = self['z_map']\n z_dist = np.linspace(min(z_map), max(z_map), len(z_map))\n\n new_z_map = np.zeros(len(z_map))\n\n new_table = self.copy()\n\n for i in range(len(new_z_map)):\n probs = np.random.sample(len(z_map))\n probs /= np.sum(probs)\n new_z_map[i] = np.random.choice(z_dist, p=probs)\n\n # Create random cdfs\n new_table['z_map'] = np.random.rand(len(z_map)) * np.max(z_map)\n cdf_x, cdf_y = compute_cdf_percentiles(\n self['fit_stack'].data,\n cdf_sigmas=np.linspace(-5, 5, 51))\n new_table['cdf_z'] = cdf_x\n\n return new_table"],"string":"[\n \"def shift(self):\\n \\\"\\\"\\\"\\n shift cluster randomly within bounds of im\\n \\\"\\\"\\\"\\n r = self.std\\n mid = self.mid_pixel #center pixel index of 384x384 image\\n delta = self.im_size - self.mid_pixel - r - 10\\n \\n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n\\n self.x += x\\n self.y += y\\n im_shift = np.roll(self.im,shift=y,axis=0)\\n self.im = np.roll(im_shift,shift=x,axis=1)\\n \\n return\",\n \"def shift_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def shift(self):\\n r = self.std\\n mid = self.mid_pixel #center pixel index of 384x384 image\\n delta = self.size - self.mid_pixel - r\\n \\n x = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n y = np.random.randint(low=-1*delta,high=delta,size=1)[0]\\n\\n self.x += x\\n self.y += y\\n image_shift = np.roll(self.image,shift=x,axis=0)\\n self.image = np.roll(image_shift,shift=y,axis=1)\\n \\n return\",\n \"def mutate_point_trig(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_trig(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_trig(mutated_genome,index)\",\n \"def shift_point_wline(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(1,max(1,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def shuffle_points(mutated_genome,index):\\n random.shuffle(mutated_genome[index][2])\",\n \"def switch_points(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point_index2 = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def shift_point_trig(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n triangle = mutated_genome[index][2]\\n seed = random.randint(0,2)\\n oldpoint = triangle[seed]\\n newpoint = (oldpoint+Xval, newpoint+Yval)\\n newtriangle = list(triangle)\\n newtriangle[seed] = newpoint\\n mutated_genome[index][2] = tuple(newtriangle)\",\n \"def random_transform(self, x, seed=None):\\n # x is a single audio, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\\n input_length = x.shape[img_row_axis]\\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\\n if x.shape[img_row_axis] >= input_length:\\n x = x[:input_length]\\n else:\\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\\n 'constant', constant_values=(0, np.mean(x)))\\n\\n if shift:\\n hx = np.random.uniform(-self.shift, self.shift)\\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\\n\\n if self.roll_range:\\n tx = np.random.uniform(-self.roll_range, self.roll_range)\\n if self.roll_range < 1:\\n tx *= x.shape[img_row_axis]\\n x = np.roll(x, int(tx), axis=(img_row_axis))\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = np.flip(x, axis=img_row_axis)\\n\\n if (self.noise):\\n if np.random.random() < 0.5:\\n if self.noise[-1] == 'Uniform':\\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\\n elif self.noise[-1] == 'Normal':\\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\\n\\n if self.brightness_range is not None:\\n x = random_brightness(x, self.brightness_range)\\n\\n return x\",\n \"def move_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\\n point = (Xval,Yval)\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n mutated_genome[index][2][point_index] = point\",\n \"def MovePoint(pos,points,s=0.5, k = 1000): \\n \\n x = [pos[0]] \\n y = [pos[1]]\\n rdm.seed(1) # comment out if you want randomness\\n for i in range(k):\\n n = len(points)\\n r = int(rdm.random()*n)\\n \\n x.append(x[i] + (points[r][0] - x[i]) * s)\\n y.append(y[i] + (points[r][1] - y[i]) * s)\\n\\n \\n return(x,y)\",\n \"def _sample_epislon(self, cur_y, cur_z):\\n old_loglik = self._loglik(cur_y, cur_z)\\n old_epislon = self.epislon\\n \\n # modify the feature ownership matrix\\n self.epislon = np.random.beta(1,1)\\n new_loglik = self._loglik(cur_y, cur_z)\\n move_prob = 1 / (1 + np.exp(old_loglik - new_loglik));\\n if random.random() < move_prob:\\n pass\\n else:\\n self.epislon = old_epislon\",\n \"def decrement_point(mutated_genome,index):\\n point_index1 = random.randint(1,max(0,len(mutated_genome[index][2])-1))\\n seed = random.randint(0,2)\\n if seed == 0:\\n point_index2 = point_index1 - 1\\n elif seed == 1:\\n point_index2 = random.randint(0, point_index1)\\n else: #seed == 2:\\n point_index2 = 0\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def mutate_point_circ(mutated_genome):\\n seed = random.randint(0,3)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_circ(mutated_genome,index)\\n elif seed == 1:\\n shift_point_circ(mutated_genome,index)\\n elif seed == 2:\\n move_radius_circ(mutated_genome,index)\\n else: #seed == 3:\\n shift_radius_circ(mutated_genome,index)\",\n \"def random_shift(x, fraction):\\n min_x, max_x = np.min(x), np.max(x)\\n m = np.random.uniform(-fraction, fraction, size=x.shape) + 1\\n return np.clip(x * m, min_x, max_x)\",\n \"def rotate_point_cloud(data):\\n rotated_data = np.zeros(data.shape, dtype=np.float32)\\n for k in xrange(data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def mutate_point_poly3(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:, idx, :]\",\n \"def random_transform_extension(self, x, y, seed=None):\\n # x is a single image, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n # use composition of homographies\\n # to generate final transform that needs to be applied\\n if self.rotation_range:\\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(-self.shear_range, self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\\n\\n transform_matrix = None\\n if theta != 0:\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n transform_matrix = rotation_matrix\\n\\n if tx != 0 or ty != 0:\\n shift_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\\n\\n if shear != 0:\\n shear_matrix = np.array([[1, -np.sin(shear), 0],\\n [0, np.cos(shear), 0],\\n [0, 0, 1]])\\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\\n\\n if zx != 1 or zy != 1:\\n zoom_matrix = np.array([[zx, 0, 0],\\n [0, zy, 0],\\n [0, 0, 1]])\\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\\n\\n if transform_matrix is not None:\\n hx, wx = x.shape[img_row_axis], x.shape[img_col_axis]\\n hy, wy = y.shape[img_row_axis], y.shape[img_col_axis]\\n transform_matrix_x = kimage.transform_matrix_offset_center(transform_matrix, hx, wx)\\n transform_matrix_y = kimage.transform_matrix_offset_center(transform_matrix, hy, wy)\\n x = apply_transform(x, transform_matrix_x, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n y = apply_transform(y, transform_matrix_y, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n if self.channel_shift_range != 0:\\n x = image.random_channel_shift(x,\\n self.channel_shift_range,\\n img_channel_axis)\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_col_axis)\\n y = kimage.flip_axis(y, img_col_axis)\\n\\n if self.vertical_flip:\\n if np.random.random() < 0.5:\\n x = kimage.flip_axis(x, img_row_axis)\\n y = kimage.flip_axis(y, img_row_axis)\\n return x, y\",\n \"def mutate_point_rect(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_rect(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_rect(mutated_genome,index)\",\n \"def shuffle_points(batch_data):\\n idx = np.arange(batch_data.shape[1])\\n np.random.shuffle(idx)\\n return batch_data[:,idx,:]\",\n \"def increment_point(mutated_genome,index):\\n point_index1 = random.randint(0,max(0,len(mutated_genome[index][2])-2))\\n seed = random.randint(0,2)\\n if seed == 0:\\n point_index2 = point_index1 + 1\\n elif seed == 1:\\n point_index2 = random.randint(point_index1,max(0,len(mutated_genome[index][2])-1))\\n else: #seed == 2:\\n point_index2 = max(0,len(mutated_genome[index][2])-1)\\n temp = mutated_genome[index][2][point_index1]\\n mutated_genome[index][2][point_index1] = mutated_genome[index][2][point_index2]\\n mutated_genome[index][2][point_index2] = temp\",\n \"def MoveRandom(self):\\n r = random.randint(0,3)\\n if r == 0: self.x += 1\\n elif r == 1: self.y += 1\\n elif r == 2: self.x -= 1\\n elif r == 3: self.y -= 1\",\n \"def move_point_trig(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\\n point = (Xval,Yval)\\n old_points = list(mutated_genome[index][2])\\n old_points[random.randint(0,2)] = point\\n mutated_genome[index][2] = tuple(old_points)\",\n \"def random_rotate(self):\\r\\n rotation = rand.randrange(0, 4, 1) # 0, 1, 2, 3\\r\\n flip = rand.randrange(0, 2, 1) # 0, 1\\r\\n new_seed = copy.deepcopy(self)\\r\\n # rotate by 90 degrees * rotation (0, 90, 180 270)\\r\\n new_seed.cells = np.rot90(new_seed.cells, rotation) \\r\\n if (flip == 1):\\r\\n # flip upside down\\r\\n new_seed.cells = np.flipud(new_seed.cells)\\r\\n new_seed.xspan = new_seed.cells.shape[0]\\r\\n new_seed.yspan = new_seed.cells.shape[1]\\r\\n return new_seed\",\n \"def random_transform(self, x):\\n pass\",\n \"def rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def random_shift(x, wrg, hrg, row_axis=0, col_axis=1, channel_axis=2,\\n fill_mode='nearest', cval=0., interpolation_order=1):\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n tx = np.random.uniform(-hrg, hrg) * h\\n ty = np.random.uniform(-wrg, wrg) * w\\n x = apply_affine_transform(x, tx=tx, ty=ty, channel_axis=channel_axis,\\n fill_mode=fill_mode, cval=cval,\\n order=interpolation_order)\\n return x\",\n \"def test_shift_point(self):\\n point = (0,0)\\n new_point = utils.shift_point(point, 3, 4)\\n self.assertEqual((3,4), new_point)\\n\\n point = (-2.34, 1.19)\\n new_point = utils.shift_point(point, 2.34, -1.19)\\n self.assertEqual((0,0), new_point)\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def augment_cloud(Ps):\\n \\\"Augmented params:\\\"\\n pc_augm_scale=0\\n pc_augm_rot=1\\n pc_augm_mirror_prob=0.5\\n pc_augm_jitter=0\\n\\n M = transforms3d.zooms.zfdir2mat(1)\\n if pc_augm_scale > 1:\\n s = random.uniform(1/pc_augm_scale, pc_augm_scale)\\n M = np.dot(transforms3d.zooms.zfdir2mat(s), M)\\n if pc_augm_rot:\\n angle = random.uniform(0, 2*math.pi)\\n M = np.dot(transforms3d.axangles.axangle2mat([0,0,1], angle), M) # z=upright assumption\\n if pc_augm_mirror_prob > 0: # mirroring x&y, not z\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [1,0,0]), M)\\n if random.random() < pc_augm_mirror_prob/2:\\n M = np.dot(transforms3d.zooms.zfdir2mat(-1, [0,1,0]), M)\\n result = []\\n for P in Ps:\\n P[:,:3] = np.dot(P[:,:3], M.T)\\n\\n if pc_augm_jitter:\\n sigma, clip= 0.01, 0.05 # https://github.com/charlesq34/pointnet/blob/master/provider.py#L74\\n P = P + np.clip(sigma * np.random.randn(*P.shape), -1*clip, clip).astype(np.float32)\\n result.append(P)\\n return result\",\n \"def mutate_point_wline(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 1: seed = 0\\n if seed == 0:\\n insert_point_wline(mutated_genome,index)\\n elif seed == 1:\\n remove_point_wline(mutated_genome,index)\\n elif seed == 2:\\n switch_points_wline(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points_wline(mutated_genome,index)\\n elif seed == 4:\\n move_point_wline(mutated_genome,index)\\n elif seed == 5:\\n shift_point_wline(mutated_genome,index)\\n elif seed == 6:\\n increment_point_wline(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point_wline(mutated_genome,index)\",\n \"def _sample_k_new(self, cur_y, cur_z):\\n N = float(len(self.obs))\\n #old_loglik = self._loglik(cur_y, cur_z)\\n\\n k_new_count = np.random.poisson(self.alpha / N)\\n if k_new_count == 0: return False\\n \\n # modify the feature ownership matrix\\n cur_z_new = np.hstack((cur_z, np.random.randint(0, 2, size = (cur_z.shape[0], k_new_count))))\\n #cur_z_new[:, [xrange(-k_new_count,0)]] = 1\\n # propose feature images by sampling from the prior distribution\\n cur_y_new = np.vstack((cur_y, np.random.binomial(1, self.theta, (k_new_count, self.d))))\\n \\n return cur_y_new.astype(np.int32), cur_z_new.astype(np.int32)\",\n \"def mutate_point_poly(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 3: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def resample_particles(self):\\n # make sure the distribution is normalized\\n self.normalize_particles()\\n\\n newParticles = []\\n for i in range(len(self.particle_cloud)):\\n # resample the same # of particles\\n choice = random_sample()\\n # all the particle weights sum to 1\\n csum = 0 # cumulative sum\\n for particle in self.particle_cloud:\\n csum += particle.w\\n if csum >= choice:\\n # if the random choice fell within the particle's weight\\n newParticles.append(deepcopy(particle))\\n break\\n self.particle_cloud = newParticles\",\n \"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\\r\\n B, N, C = batch_data.shape\\r\\n assert(clip > 0)\\r\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\r\\n jittered_data += batch_data\\r\\n return jittered_data\",\n \"def randomShiftVector(values, smin, smax):\\n\\tshift = np.random.uniform(smin, smax)\\n\\treturn list(map(lambda va: va + shift, values))\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def crossover(new_pop, k):\\n shuffle(new_pop)\\n for i in range(len(new_pop) // 2):\\n points = random.sample(range(1, len(new_pop[i])), k)\\n points.sort()\\n for fold in range(k):\\n x = points[fold]\\n tmp = new_pop[2 * i][:x].copy()\\n new_pop[2 * i][:x], new_pop[2 * i + 1][:x] = new_pop[2 * i +\\n 1][:x], tmp\\n return new_pop\",\n \"def random_shift(x, wrg, hrg, row_axis=1, col_axis=2, channel_axis=0,\\n fill_mode='nearest', cval=0.):\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n tx = np.random.uniform(-hrg, hrg) * h\\n ty = np.random.uniform(-wrg, wrg) * w\\n translation_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n\\n transform_matrix = translation_matrix # no need to do offset\\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\\n return x\",\n \"def lift(point):\\n return gs.copy(point)\",\n \"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\\n B, N, C = batch_data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += batch_data\\n return jittered_data\",\n \"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\\n B, N, C = batch_data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += batch_data\\n return jittered_data\",\n \"def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):\\n B, N, C = batch_data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += batch_data\\n return jittered_data\",\n \"def _get_random_transform(self, img_shape, seed=None):\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if self.rotation_range:\\n theta = np.random.uniform(\\n -self.rotation_range,\\n self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n try: # 1-D array-like or int\\n tx = np.random.choice(self.height_shift_range)\\n tx *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n tx = np.random.uniform(-self.height_shift_range,\\n self.height_shift_range)\\n if np.max(self.height_shift_range) < 1:\\n tx *= img_shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n try: # 1-D array-like or int\\n ty = np.random.choice(self.width_shift_range)\\n ty *= np.random.choice([-1, 1])\\n except ValueError: # floating point\\n ty = np.random.uniform(-self.width_shift_range,\\n self.width_shift_range)\\n if np.max(self.width_shift_range) < 1:\\n ty *= img_shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(\\n -self.shear_range,\\n self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(\\n self.zoom_range[0],\\n self.zoom_range[1],\\n 2)\\n\\n flip_horizontal = (np.random.random() < 0.5) * self.horizontal_flip\\n flip_vertical = (np.random.random() < 0.5) * self.vertical_flip\\n\\n channel_shift_intensity = None\\n if self.channel_shift_range != 0:\\n channel_shift_intensity = np.random.uniform(-self.channel_shift_range,\\n self.channel_shift_range)\\n\\n brightness = None\\n if self.brightness_range is not None:\\n brightness = np.random.uniform(self.brightness_range[0],\\n self.brightness_range[1])\\n\\n transform_parameters = {'theta': theta,\\n 'tx': tx,\\n 'ty': ty,\\n 'shear': shear,\\n 'zx': zx,\\n 'zy': zy,\\n 'flip_horizontal': flip_horizontal,\\n 'flip_vertical': flip_vertical,\\n 'channel_shift_intensity': channel_shift_intensity,\\n 'brightness': brightness}\\n\\n return transform_parameters\",\n \"def jitter_point_cloud(batch_data, sigma=0.02, clip=0.05):\\n B, N, C = batch_data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += batch_data\\n return jittered_data\",\n \"def shift_augmentation():\\n shift = np.random.randint(-200, 201, size=2)\\n return lambda image: shift_with_extension(image, shift)\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def repick(g1_x, g1_y, g1_z):\\n i = random.randint(0, len(g1_x) - 1)\\n x = g1_x[i]\\n y = g1_y[i]\\n z = g1_z[i]\\n return x, y, z\",\n \"def random_scale_point_cloud(batch_data, scale_low=0.8, scale_high=1.25):\\n B, N, C = batch_data.shape\\n scales = np.random.uniform(scale_low, scale_high, B)\\n for batch_index in range(B):\\n batch_data[batch_index,:,:] *= scales[batch_index]\\n return batch_data\",\n \"def move_point_wline(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth/5.),int(imagewidth*6./5.))\\n Yval = random.randint(-int(imageheight/5.),int(imageheight*6./5.))\\n point = (Xval,Yval)\\n point_index = random.randint(1,max(1,len(mutated_genome[index][2])-1))\\n mutated_genome[index][2][point_index] = point\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def shift_point_circ(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n circle = mutated_genome[index][2]\\n newcircle = (circle[0]+Xval,circle[1]+Yval,circle[2])\\n mutated_genome[index][2] = newcircle\",\n \"def random_shift(image, wsr=0.1, hsr=0.1):\\n height, width, _ = common_layers.shape_list(image)\\n width_range, height_range = wsr*width, hsr*height\\n height_translations = tf.random_uniform((1,), -height_range, height_range)\\n width_translations = tf.random_uniform((1,), -width_range, width_range)\\n translations = tf.concat((height_translations, width_translations), axis=0)\\n return tf.contrib.image.translate(image, translations=translations)\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def random_shift(self, X, y_2d, im_h, im_w, scale):\\n wrng = np.random.randint(-int(im_w*scale), int(im_w*scale))\\n hrng = np.random.randint(-int(im_h*scale), int(im_h*scale))\\n\\n X = self.shift_im(X, wrng)\\n X = self.shift_im(X, hrng, dim=1)\\n\\n y_2d = self.shift_im(y_2d, wrng)\\n y_2d = self.shift_im(y_2d, hrng, dim=1)\\n\\n return X, y_2d\",\n \"def generate_shift(self, k=1, static=False):\\n if static:\\n shift = np.zeros((k, 2))\\n else:\\n shift = np.array(self.environment_size)/2 * np.random.rand(k, 2) - np.array(self.environment_size)/4\\n return shift\",\n \"def generate_shift(self, k=1, static=False):\\n if static:\\n shift = np.zeros((k, 2))\\n else:\\n shift = np.array(self.environment_size)/2 * np.random.rand(k, 2) - np.array(self.environment_size)/4\\n return shift\",\n \"def move(self):\\n if self._z >= 75:\\n a = random.random()\\n print(str(a))\\n if a < 0.2:\\n self._z += 1\\n if a > 0.2 and a < 0.9:\\n self._z -= 1\\n if a > 0.9:\\n self._z = self._z\\n else: \\n self._z -= 1\\n \\n b = random.random()\\n print(str(b))\\n if b < 0.1:\\n self._y += 1\\n if b > 0.1 and b < 0.2:\\n self._y -= 1\\n if b > 0.2 and b < 0.25:\\n self._x -= 1\\n if b > 0.25:\\n self._x += 1\",\n \"def shuffle_points(data):\\n idx = np.arange(data.shape[1])\\n np.random.shuffle(idx)\\n return data[:, idx, :], idx\",\n \"def random_channel_swap(self, img, p = 0.5):\\n if self.decision(p):\\n img[:, :, 0], img[:, :, 1] = img[:, :, 1], img[:, :, 0]\\n if self.decision(p):\\n img[:, :, 1], img[:, :, 2] = img[:, :, 2], img[:, :, 1]\\n if self.decision(p):\\n img[:, :, 2], img[:, :, 0] = img[:, :, 0], img[:, :, 2]\\n return img\",\n \"def augmenter(x, y):\\n # Note that we only use fliprots along axis=(1,2), i.e. the yx axis\\n # as 3D microscopy acquisitions are usually not axially symmetric\\n x, y = random_fliprot(x, y, axis=(1, 2))\\n x = random_intensity_change(x)\\n return x, y\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def shuffle(self):\\n self.__c_elem().melange()\",\n \"def jitter_point_cloud(data, sigma=0.25, clip=1):\\n B, N, C = data.shape\\n assert(clip > 0)\\n jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)\\n jittered_data += data\\n return jittered_data\",\n \"def captureNewDataPoint(self):\\n return 2.0*rand()-1.0\",\n \"def _permute_sign(data, seed, return_stat=\\\"mean\\\"):\\n\\n random_state = np.random.RandomState(seed)\\n new_dat = data * random_state.choice([1, -1], len(data))\\n if return_stat == \\\"ceof\\\":\\n return np.mean(new_dat)\\n elif return_stat == \\\"t-stat\\\":\\n return np.mean(new_dat) / (np.std(new_dat, ddof=1) / np.sqrt(len(new_dat)))\",\n \"def sample(self):\\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\\n x = self.x_prev\\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\\n self.dt\\n ) * np.random.normal(size=self.mu.shape)\\n self.x_prev = x + dx\\n return self.x_prev\",\n \"def shuffle(self): \\n for x in range(12):\\n self.right(primary=-60, counter=0)\\n time.sleep(.1)\\n self.left(primary=-60, counter=0)\\n time.sleep(.1)\\n self.stop()\",\n \"def random_transform(self, x_batch):\\n # x is a single image, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_col_axis = self.col_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n rt_batch = np.zeros_like(x_batch)\\n for i in xrange(x_batch.shape[0]):\\n x = x_batch[i]\\n\\n # use composition of homographies\\n # to generate final transform that needs to be applied\\n if self.rotation_range:\\n theta = np.pi / 180 * np.random.uniform(-self.rotation_range, self.rotation_range)\\n else:\\n theta = 0\\n\\n if self.height_shift_range:\\n tx = np.random.uniform(-self.height_shift_range, self.height_shift_range) * x.shape[img_row_axis]\\n else:\\n tx = 0\\n\\n if self.width_shift_range:\\n ty = np.random.uniform(-self.width_shift_range, self.width_shift_range) * x.shape[img_col_axis]\\n else:\\n ty = 0\\n\\n if self.shear_range:\\n shear = np.random.uniform(-self.shear_range, self.shear_range)\\n else:\\n shear = 0\\n\\n if self.zoom_range[0] == 1 and self.zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(self.zoom_range[0], self.zoom_range[1], 2)\\n\\n transform_matrix = None\\n if theta != 0:\\n rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n transform_matrix = rotation_matrix\\n\\n if tx != 0 or ty != 0:\\n shift_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n transform_matrix = shift_matrix if transform_matrix is None else np.dot(transform_matrix, shift_matrix)\\n\\n if shear != 0:\\n shear_matrix = np.array([[1, -np.sin(shear), 0],\\n [0, np.cos(shear), 0],\\n [0, 0, 1]])\\n transform_matrix = shear_matrix if transform_matrix is None else np.dot(transform_matrix, shear_matrix)\\n\\n if zx != 1 or zy != 1:\\n zoom_matrix = np.array([[zx, 0, 0],\\n [0, zy, 0],\\n [0, 0, 1]])\\n transform_matrix = zoom_matrix if transform_matrix is None else np.dot(transform_matrix, zoom_matrix)\\n\\n if transform_matrix is not None:\\n h, w = x.shape[img_row_axis], x.shape[img_col_axis]\\n transform_matrix = transform_matrix_offset_center(transform_matrix, h, w)\\n x = apply_transform(x, transform_matrix, img_channel_axis,\\n fill_mode=self.fill_mode, cval=self.cval)\\n\\n if self.channel_shift_range != 0:\\n x = random_channel_shift(x,\\n self.channel_shift_range,\\n img_channel_axis)\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = flip_axis(x, img_col_axis)\\n\\n if self.vertical_flip:\\n if np.random.random() < 0.5:\\n x = flip_axis(x, img_row_axis)\\n\\n if self.random_curves_strength > 0.:\\n x = random_curves_transform(x,self.random_curves_strength)\\n\\n rt_batch[i] = x\\n\\n return rt_batch\",\n \"def shuffle(self):\\r\\n #\\r\\n shuffled_seed = copy.deepcopy(self)\\r\\n #\\r\\n # for each location [x0][y0], randomly choose another location\\r\\n # [x1][y1] and swap the values of the cells in the two locations.\\r\\n #\\r\\n for x0 in range(self.xspan):\\r\\n for y0 in range(self.yspan):\\r\\n x1 = rand.randrange(self.xspan)\\r\\n y1 = rand.randrange(self.yspan)\\r\\n temp = shuffled_seed.cells[x0][y0]\\r\\n shuffled_seed.cells[x0][y0] = shuffled_seed.cells[x1][y1]\\r\\n shuffled_seed.cells[x1][y1] = temp\\r\\n #\\r\\n return shuffled_seed\",\n \"def shift_point_rect(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n rectangle = mutated_genome[index][2]\\n seed = random.randint(0,1)\\n oldpoint = rectangle[seed]\\n newpoint = (oldpoint+Xval, newpoint+Yval)\\n newrectangle = list(rectangle)\\n newrectangle[seed] = newpoint\\n mutated_genome[index][2] = tuple(newrectangle)\",\n \"def next_sample(self, z):\\n xp = self.A @ self.x\\n Pp = self.A @ self.P @ self.A.T + self.Q\\n\\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\\n\\n self.x = xp + self.K @ (z - self.H @ xp)\\n self.P = Pp - self.K @ self.H @ Pp\\n return self.x\",\n \"def random_step(self):\\n pos = [i for i in range(9) if self.grid[i] == 0]\\n move = random.choice(pos)\\n return self.step(move)\",\n \"def random_step(self):\\n pos = [i for i in range(9) if self.grid[i] == 0]\\n move = random.choice(pos)\\n return self.step(move)\",\n \"def mutate_random(self, point, population):\\n other = Point(self.model.generate())\\n other.evaluate(self.model)\\n while other in population or other == point:\\n other = Point(self.model.generate())\\n other.evaluate(self.model)\\n return other\",\n \"def shift_shuffle(self, continuum: Continuum) -> None:\\n shift_max = self.magnitude * self.SHIFT_FACTOR * \\\\\\n self._reference_continuum.avg_length_unit\\n for annotator in continuum.annotators:\\n for unit in continuum[annotator]:\\n continuum.remove(annotator, unit)\\n start_seg, end_seg = 0.0, 0.0\\n while start_seg >= end_seg:\\n start_seg = unit.segment.start + np.random.uniform(-1, 1) * shift_max\\n end_seg = unit.segment.end + np.random.uniform(-1, 1) * shift_max\\n continuum.add(annotator, Segment(start_seg, end_seg), unit.annotation)\",\n \"def changeState(self, xyPoints):\\n nPts = len(xyPoints)\\n ind0 = random.randint(1, nPts-1)\\n ind1 = random.randint(1, nPts-1)\\n while ind1 == ind0:\\n ind1 = random.randint(1, nPts-1)\\n # make copy of the sources to make sure the swap works correctly\\n xyPoints[ind0], xyPoints[ind1] = tuple(xyPoints[ind1]), tuple(xyPoints[ind0])\",\n \"def resample(self):\\n self.X = np.random.uniform(-1, 1, (100, 2))\\n self.generate_y()\\n self.phi = None\\n self.K = 0\\n self.centers = None\\n self.cluster_sizes = None\\n self.g = None\\n self.gamma = None\",\n \"def mutate(x, rvs, point=(0,0), insert=(0,0,None), delete=(0,0)):\\n data = x.data\\n idx = x.indices\\n if idx.size==0:\\n return x\\n n_point = np.random.binomial(point[0], point[1])\\n i_point = np.random.choice(x.size, size=n_point, replace=False)\\n data[i_point] = rvs(n_point)\\n # insertion\\n n_insert = np.random.binomial(insert[0], insert[1])\\n for _ in range(n_insert):\\n while True:\\n insert_idx = np.random.choice(insert[2]) if insert[2]\\\\\\n else np.random.choice(x.shape[0])\\n if insert_idx not in idx: break\\n idx = np.append(idx, insert_idx)\\n data = np.append(data, rvs(1))\\n # deletion\\n n_delete = np.random.binomial(delete[0], delete[1])\\n i_delete = np.random.choice(idx.size, size=n_delete, replace=False)\\n idx = np.delete(idx, i_delete)\\n data = np.delete(data, i_delete)\\n y = sp.sparse.csc_matrix((data, (idx, np.zeros(idx.shape, dtype=int))),\\n shape=x.shape)\\n return y\",\n \"def __replace_by_noise(self, c):\\n n = self.X_train_raw.shape[0]\\n temp = []\\n for r in xrange(0, n):\\n temp.append(self.X_train_raw[r][c])\\n shuffle(temp)\\n for r in xrange(0, n):\\n self.X_train_raw[r][c] = temp[r]\",\n \"def random(self):\\n adj = self.adjacent()\\n self.switch(random.choice([pos for pos in adj if self.in_grid(pos) and pos != self.prev]))\",\n \"def remove_point(mutated_genome,index):\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n del mutated_genome[index][2][point_index]\",\n \"def move_egg(array):\\n new_array = deepcopy(array)\\n old_x, old_y = get_random_position(array, 1)\\n new_x, new_y = get_random_position(array, 0)\\n new_array[old_y][old_x] = 0\\n new_array[new_y][new_x] = 1\\n return new_array\",\n \"def move_to_random_pos(self):\\n newpos = [(np.random.rand() - 0.5) * 0.1,\\n (np.random.rand() - 0.5) * 0.1,\\n np.random.rand() * 0.9 + 0.2]\\n self.move_to(newpos)\",\n \"def mc_micro_sweep(self): \\n for i in range(self.N):\\n if random.random()>0.3:\\n self.mc_update_micro_fixed(i,xy = True)\",\n \"def mutate(self, size):\\n rand = random.random()\\n if rand <= 0.5:\\n print u\\\"changing colour\\\"\\n idx = random.randrange(0, 4)\\n value = random.randrange(0, 256)\\n colour = list(self.colour)\\n colour[idx] = value\\n self.colour = tuple(colour)\\n else:\\n print u\\\"changing point\\\"\\n idx = random.randrange(0, len(self.points))\\n point = generate_point(size[0], size[1])\\n self.points[idx] = point\",\n \"def _sample_z(self, a):\\n r = np.random.rand()\\n return ((1 + r * (a - 1))**2) / a\",\n \"def random_crop(image, steering = 0.0, tx_lower = -20, tx_upper = 20, ty_lower = -2, ty_upper = 2, rand = True):\\n\\n shape = image.shape\\n (col_start, col_end) = (abs(tx_lower), shape[1] - tx_upper)\\n horizon = 60\\n bonnet = 136\\n if rand:\\n tx = np.random.randint(tx_lower, tx_upper + 1)\\n ty = np.random.randint(ty_lower, ty_upper + 1)\\n else:\\n (tx, ty) = (0, 0)\\n\\n crop = image[horizon + ty: bonnet + ty, col_start + tx: col_end + tx, :]\\n image = cv2.resize(crop, (320, 160), cv2.INTER_AREA)\\n # the steering variable needs to be updated to counteract the shift \\n if tx_lower != tx_upper:\\n dsteering = -tx / (tx_upper - tx_lower) / 3.0\\n else:\\n dsteering = 0\\n steering += dsteering\\n\\n return image, steering\",\n \"def make_temporally_misaligned(x, n_per_spike=1, min_shift='auto',\\n max_shift='auto'):\\n n_spikes, waveform_length, n_neigh = x.shape\\n n_out = int(n_spikes * n_per_spike)\\n\\n if max_shift == 'auto':\\n max_shift = int(0.5 * waveform_length)\\n\\n if min_shift == 'auto':\\n min_shift = int(0.1 * waveform_length)\\n\\n x_temporally = np.zeros((n_out, waveform_length, n_neigh))\\n\\n logger.debug('Making spikes with max_shift: %i, output shape: %s',\\n max_shift, x_temporally.shape)\\n\\n for j in range(n_out):\\n\\n shift = random.choice([-1, 1]) * random.randint(min_shift, max_shift)\\n\\n idx = np.random.choice(x.shape[0], 1, replace=True)[0]\\n spike = x[idx]\\n\\n if shift > 0:\\n x_temporally[j, :(x_temporally.shape[1]-shift)] += spike[shift:]\\n\\n elif shift < 0:\\n x_temporally[\\n j, (-shift):] += spike[:(x_temporally.shape[1]+shift)]\\n else:\\n x_temporally[j] += spike\\n\\n return x_temporally\",\n \"def quick_inplace_random(array, left=0, right=None):\\n if right is None:\\n right = len(array)-1\\n if left < right:\\n pivot_ind = random.randint(left,right)\\n pivot_new_ind = Quick.partition(array, left, right, pivot_ind)\\n Quick.quick_inplace_random(array, left, pivot_new_ind-1)\\n Quick.quick_inplace_random(array, pivot_new_ind+1, right)\",\n \"def random():\\n np.random.seed(0)\",\n \"def seed(seed: int):\\n # all sampling is actually happening in the move_cube module\\n move_cube.seed(seed)\",\n \"def sample_points(x, n_samples, axis=0, replace=True):\\n n_original = x.shape[axis]\\n indices = np.random.choice(n_original, n_samples, replace=replace)\\n return x.take(indices, axis=axis)\",\n \"def mutation(self):\\n\\n for r in range(self.pop_num*3, 5): # Mutation.\\n for w in range(0,self.length): \\n if random.random()<0.2: \\n self.par_and_sons[r].A[w] = self.par_and_sons[r].A[w] + np.random.randint(-20, 20) # Offset + -20 pixels.\",\n \"def point_random_position(self, point_distribution, mask):\\n batch_size = point_distribution.size(0)\\n mask_np = to_np(mask) # batch x time\\n indices = []\\n for i in range(batch_size):\\n msk = mask_np[i] # time\\n indices.append(np.random.choice(len(msk), 2, p=msk / np.sum(msk, -1)))\\n indices = to_pt(np.stack(indices, 0), self.use_cuda) # batch x 2\\n return indices\",\n \"def uniform_redshift(self):\\n z_map = self['z_map']\\n z_dist = np.linspace(min(z_map), max(z_map), len(z_map))\\n\\n new_z_map = np.zeros(len(z_map))\\n\\n new_table = self.copy()\\n\\n for i in range(len(new_z_map)):\\n probs = np.random.sample(len(z_map))\\n probs /= np.sum(probs)\\n new_z_map[i] = np.random.choice(z_dist, p=probs)\\n\\n # Create random cdfs\\n new_table['z_map'] = np.random.rand(len(z_map)) * np.max(z_map)\\n cdf_x, cdf_y = compute_cdf_percentiles(\\n self['fit_stack'].data,\\n cdf_sigmas=np.linspace(-5, 5, 51))\\n new_table['cdf_z'] = cdf_x\\n\\n return new_table\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72441024","0.6811636","0.64971095","0.61066484","0.60589975","0.5939156","0.593459","0.5932551","0.5909121","0.57994634","0.57626474","0.5751564","0.57320094","0.57160926","0.5685124","0.56692094","0.56554824","0.564319","0.56338567","0.5614417","0.56072867","0.559016","0.5574786","0.5557774","0.554621","0.5539712","0.551367","0.5493715","0.5487462","0.54678863","0.54603237","0.54561484","0.5454645","0.5448451","0.5445202","0.5442251","0.5439643","0.54385555","0.54385555","0.54385555","0.54333663","0.5431692","0.5412432","0.54097575","0.54097575","0.54097575","0.5408472","0.54035544","0.5402516","0.54002583","0.54002583","0.53880996","0.5381484","0.5364802","0.53641075","0.5319167","0.5314167","0.5314089","0.5308778","0.52984196","0.52984196","0.52983636","0.5295887","0.5273645","0.5265738","0.5255024","0.5253247","0.52368","0.5232729","0.52239376","0.5222864","0.52179176","0.51929307","0.518079","0.51789916","0.51625586","0.51530886","0.51530886","0.5153063","0.5145377","0.5142009","0.5138288","0.51207805","0.51119286","0.51093876","0.51009864","0.5093038","0.50879043","0.50667906","0.5063965","0.50601166","0.5057677","0.5044801","0.50369483","0.50276154","0.5016683","0.50162","0.50146806","0.5013885","0.5013388"],"string":"[\n \"0.72441024\",\n \"0.6811636\",\n \"0.64971095\",\n \"0.61066484\",\n \"0.60589975\",\n \"0.5939156\",\n \"0.593459\",\n \"0.5932551\",\n \"0.5909121\",\n \"0.57994634\",\n \"0.57626474\",\n \"0.5751564\",\n \"0.57320094\",\n \"0.57160926\",\n \"0.5685124\",\n \"0.56692094\",\n \"0.56554824\",\n \"0.564319\",\n \"0.56338567\",\n \"0.5614417\",\n \"0.56072867\",\n \"0.559016\",\n \"0.5574786\",\n \"0.5557774\",\n \"0.554621\",\n \"0.5539712\",\n \"0.551367\",\n \"0.5493715\",\n \"0.5487462\",\n \"0.54678863\",\n \"0.54603237\",\n \"0.54561484\",\n \"0.5454645\",\n \"0.5448451\",\n \"0.5445202\",\n \"0.5442251\",\n \"0.5439643\",\n \"0.54385555\",\n \"0.54385555\",\n \"0.54385555\",\n \"0.54333663\",\n \"0.5431692\",\n \"0.5412432\",\n \"0.54097575\",\n \"0.54097575\",\n \"0.54097575\",\n \"0.5408472\",\n \"0.54035544\",\n \"0.5402516\",\n \"0.54002583\",\n \"0.54002583\",\n \"0.53880996\",\n \"0.5381484\",\n \"0.5364802\",\n \"0.53641075\",\n \"0.5319167\",\n \"0.5314167\",\n \"0.5314089\",\n \"0.5308778\",\n \"0.52984196\",\n \"0.52984196\",\n \"0.52983636\",\n \"0.5295887\",\n \"0.5273645\",\n \"0.5265738\",\n \"0.5255024\",\n \"0.5253247\",\n \"0.52368\",\n \"0.5232729\",\n \"0.52239376\",\n \"0.5222864\",\n \"0.52179176\",\n \"0.51929307\",\n \"0.518079\",\n \"0.51789916\",\n \"0.51625586\",\n \"0.51530886\",\n \"0.51530886\",\n \"0.5153063\",\n \"0.5145377\",\n \"0.5142009\",\n \"0.5138288\",\n \"0.51207805\",\n \"0.51119286\",\n \"0.51093876\",\n \"0.51009864\",\n \"0.5093038\",\n \"0.50879043\",\n \"0.50667906\",\n \"0.5063965\",\n \"0.50601166\",\n \"0.5057677\",\n \"0.5044801\",\n \"0.50369483\",\n \"0.50276154\",\n \"0.5016683\",\n \"0.50162\",\n \"0.50146806\",\n \"0.5013885\",\n \"0.5013388\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7352118"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9471,"cells":{"query":{"kind":"string","value":"Randomly scale the point cloud. Scale is per point cloud."},"document":{"kind":"string","value":"def random_scale_point_cloud(batch_data, scale_low=0.8, scale_high=1.25):\n B, N, C = batch_data.shape\n scales = np.random.uniform(scale_low, scale_high, B)\n for batch_index in range(B):\n batch_data[batch_index,:,:] *= scales[batch_index]\n return batch_data"},"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 scale_point_cloud(batch_data, scale_ratio=0.8):\n B, N, C = batch_data.shape\n scale = np.random.uniform(scale_ratio,1/scale_ratio,(B,1,1))\n scaled_data = batch_data*scale\n return scaled_data","def ScalePoints(points, sigma = 0.02):\n assert(points.shape[1]==3)\n\n scale = np.random.uniform(1-sigma, 1+sigma)\n scale_matrix = np.array([[scale, 0, 0],\n [0, scale, 0],\n [0, 0, scale]])\n scaled = np.dot(points, scale_matrix)\n\n return scaled","def _random_scale(self, results):\n # For multi-scale training\n shuffle(self.img_scale)\n \n if self.multiscale_mode == 'range':\n scale, scale_idx = self.random_sample_ratio(\n self.img_scale[0], self.ratio_range, self.ratio_hr_lr)\n elif self.multiscale_mode == 'value':\n scale, scale_idx = self.random_select_ratio(self.img_scale[0], self.ratio_range, self.ratio_hr_lr)\n else:\n raise NotImplementedError\n\n results['scale'] = scale\n results['scale_idx'] = scale_idx","def resample_particles(self):\n # make sure the distribution is normalized\n self.normalize_particles()\n\n newParticles = []\n for i in range(len(self.particle_cloud)):\n # resample the same # of particles\n choice = random_sample()\n # all the particle weights sum to 1\n csum = 0 # cumulative sum\n for particle in self.particle_cloud:\n csum += particle.w\n if csum >= choice:\n # if the random choice fell within the particle's weight\n newParticles.append(deepcopy(particle))\n break\n self.particle_cloud = newParticles","def _random_scale(self, results):\n\n if self.ratio_range is not None:\n scale, scale_idx = self.random_sample_ratio(\n self.img_scale[0], self.ratio_range)\n elif len(self.img_scale) == 1:\n scale, scale_idx = self.img_scale[0], 0\n elif self.multiscale_mode == 'range':\n scale, scale_idx = self.random_sample(self.img_scale)\n elif self.multiscale_mode == 'value':\n scale, scale_idx = self.random_select(self.img_scale)\n else:\n raise NotImplementedError\n\n results['scale'] = scale\n results['scale_idx'] = scale_idx","def _getScalesRand(self):\n if self.P > 1:\n scales = []\n for term_i in range(self.n_randEffs):\n _scales = sp.randn(self.diag[term_i].shape[0])\n if self.jitter[term_i] > 0:\n _scales = sp.concatenate(\n (_scales, sp.array([sp.sqrt(self.jitter[term_i])])))\n scales.append(_scales)\n scales = sp.concatenate(scales)\n else:\n scales = sp.randn(self.vd.getNumberScales())\n return scales","def _random_scale(self, waveform, prob):\n # Get random true or false\n prediction = self._random_true_false(prob=prob)\n\n # Apply random multiplication factor\n waveform = tf.cond(prediction, lambda: self._scale(waveform=waveform),\n lambda: self._do_nothing(waveform=waveform))\n\n return waveform","def _scale(waveform):\n # Get random scale factor\n scale_factor = tf.random_uniform(shape=[], minval=0.5, maxval=2.5, dtype=tf.float32)\n\n return waveform * scale_factor","def perturb_point(self, x, scale):\n x_samp = x + (scale / 2.0) * (np.random.rand(3) - 0.5)\n return x_samp","def scale(self, points, inplace=True):\n points = np.array(points).astype(float)\n if inplace==False:\n points = points.copy()\n # if len(points.shape) == 1:\n # points = points[None,:]\n # if len(points.shape) != 2:\n # logger.error(\"cannot scale array of dimensions\".format(len(points.shape)))\n points -= self.origin\n points /= self.scale_factor\n return points","def scale(self):\n return self.distribution.scale","def scale(self,scale_by):\n x = self._x * scale_by\n y = self._y * scale_by\n return Point(x,y)","def ScaleShape(shape, scale_x, scale_y):\n for i, pt in enumerate(shape.points):\n x, y = pt\n shape.points[i] = [scale_x * x, scale_y * y]","def scale(self, scale):\n\t\tself._current_score *= scale","def scale(self, scale):\n self.coords = self.coords * scale\n return self","def random_scale(imgs, DIFFICULTY):\n MULTIPLY_SCALES = [\n [1, 1],\n [0.9, 1.1],\n [0.85, 1.15],\n [0.8, 1.2],\n [0.75, 1.25],\n [0.7, 1.3],\n [0.65, 1.325],\n [0.6, 1.35],\n [0.55, 1.375],\n [0.50, 1.4],\n [0.48, 1.42],\n [0.46, 1.44],\n [0.44, 1.46],\n [0.42, 1.48],\n [0.4, 1.5],\n [0.35, 1.6],\n ]\n channels = imgs.shape[-1]\n scales = tf.gather(MULTIPLY_SCALES, DIFFICULTY)\n scales = tf.random.uniform([channels], minval=scales[0], maxval=scales[1])\n imgs = imgs * scales\n return imgs","def set_training_random_scale_factors(self, scale_min, scale_max):\n # Select a random scale factor.\n random_scale_factor = tf.random_uniform([], scale_min, scale_max)\n scaled_size = tf.to_int32(random_scale_factor * self._output_size)\n\n # Recompute the accurate scale_factor using rounded scaled image size.\n height = tf.shape(self._image)[0]\n width = tf.shape(self._image)[1]\n max_image_size = tf.to_float(tf.maximum(height, width))\n image_scale = tf.to_float(scaled_size) / max_image_size\n\n # Select non-zero random offset (x, y) if scaled image is larger than\n # self._output_size.\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\n offset_y = tf.to_float(scaled_height - self._output_size)\n offset_x = tf.to_float(scaled_width - self._output_size)\n offset_y = tf.maximum(0.0, offset_y) * tf.random_uniform([], 0, 1)\n offset_x = tf.maximum(0.0, offset_x) * tf.random_uniform([], 0, 1)\n offset_y = tf.to_int32(offset_y)\n offset_x = tf.to_int32(offset_x)\n self._image_scale = image_scale\n self._scaled_height = scaled_height\n self._scaled_width = scaled_width\n self._crop_offset_x = offset_x\n self._crop_offset_y = offset_y","def scale_data_point(self, data_point):\n \n data_point_scaled = pd.Series(self.scaler.transform(data_point[self.feature_names].to_numpy().reshape(1, -1)).ravel())\n data_point_scaled.name = data_point.name\n data_point_scaled.index = self.feature_names\n \n # Set any values > 1 to 1. This is only used in visualization.\n data_point_scaled = data_point_scaled.where(data_point_scaled <= 1.0, 1.0)\n #data_point_scaled.values = data_point_scaled.values.apply(> 1.0 else 1.0 for y in x])\n\n return data_point_scaled","def mutate(self, size):\n rand = random.random()\n if rand <= 0.5:\n print u\"changing colour\"\n idx = random.randrange(0, 4)\n value = random.randrange(0, 256)\n colour = list(self.colour)\n colour[idx] = value\n self.colour = tuple(colour)\n else:\n print u\"changing point\"\n idx = random.randrange(0, len(self.points))\n point = generate_point(size[0], size[1])\n self.points[idx] = point","def test_set_scale():\n data = io.create_sample_Dataset()\n tmp = data.piv.set_scale(1.0)\n assert np.allclose(tmp[\"x\"], data[\"x\"])\n\n tmp = data.copy()\n tmp.piv.set_scale(2.0)\n tmp_mean = tmp[\"u\"].mean(dim=(\"t\", \"x\", \"y\")).values\n data_mean = data[\"u\"].mean(dim=(\"t\", \"x\", \"y\")).values\n assert np.allclose(tmp_mean / data_mean, 2.0)","def random_transform(self, x, seed=None):\n # x is a single audio, so it doesn't have image number at index 0\n img_row_axis = self.row_axis - 1\n img_channel_axis = self.channel_axis - 1\n\n if seed is not None:\n np.random.seed(seed)\n\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\n input_length = x.shape[img_row_axis]\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\n if x.shape[img_row_axis] >= input_length:\n x = x[:input_length]\n else:\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\n 'constant', constant_values=(0, np.mean(x)))\n\n if shift:\n hx = np.random.uniform(-self.shift, self.shift)\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\n\n if self.roll_range:\n tx = np.random.uniform(-self.roll_range, self.roll_range)\n if self.roll_range < 1:\n tx *= x.shape[img_row_axis]\n x = np.roll(x, int(tx), axis=(img_row_axis))\n\n if self.horizontal_flip:\n if np.random.random() < 0.5:\n x = np.flip(x, axis=img_row_axis)\n\n if (self.noise):\n if np.random.random() < 0.5:\n if self.noise[-1] == 'Uniform':\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\n elif self.noise[-1] == 'Normal':\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\n\n if self.brightness_range is not None:\n x = random_brightness(x, self.brightness_range)\n\n return x","def scale_uniform(self, s: float):\n self.vertices = [v * s for v in self.vertices]\n return self","def rescale(self, points, inplace=True):\n if inplace == False:\n points = points.copy()\n points *= self.scale_factor\n points += self.origin\n return points","def random_subsample(cloud, sample_size, replace=False):\n\n # Handle small point clouds\n if cloud.shape[0] <= sample_size:\n warn(\"(code 1) Point cloud is already <= desired sample size. \" +\n \"No subsampling is performed.\")\n return cloud\n\n # Perform subsamping\n sample_indices = np.random.choice(np.arange(cloud.shape[0]),\n sample_size, replace=False)\n cloud_subs = cloud[sample_indices]\n\n # Return result\n return cloud_subs","def scale(x, p=2, inplace=False):\n return x / np.linalg.norm(x, ord=p)","def scale(self,s):\n return Vector(self.x * s, self.y * s, self.z * s)","def scale(self, factor):\n new = self.copy()\n new.d.clear()\n\n for val, prob in self.items():\n new.set(val * factor, prob)\n return new","def scale_point(point, centroid, scale):\n point = np.asarray(point)\n centroid = centroid[:2]\n vector = ((point - centroid)*scale) + centroid\n return vector","def random_transform(self, x):\n pass","def scale(self, size=128):\n scale_factor = size / max(self.voxels.shape)\n self.voxels = ndimage.zoom(self.voxels, scale_factor)\n self.point_position = self.point_position * scale_factor\n self.voxel_size = False # To ignore this\n \n return(self)","def scale(x_range=1, y_range=1):\r\n x = rand_val(x_range)\r\n y = rand_val(y_range)\r\n return np.array(((x, 0, 0),\r\n (0, y, 0),\r\n (0, 0, 1)), dtype=np.float)","def scale(self, x, y, z) -> None:\n ...","def scale(self, factor: float) -> Point:\n return Point(self.x * factor, self.y * factor)","def scale(self, sc):\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\n return self","def format_point_cloud(self, pc, num_points):\n resized_pc = np.zeros([num_points, 3])\n if len(pc) > num_points:\n # Randomly sample point cloud to reduce size\n resized_pc = pc[np.random.choice(pc.shape[0], num_points,\n replace=False), :]\n elif len(pc) < num_points:\n # Duplicate last point to fill point cloud. Because of the max function\n # the duplicated points will not affect the output\n resized_pc[:len(pc)] = pc\n resized_pc[len(pc):] = pc[-1]\n else:\n resized_pc = pc\n\n return resized_pc","def scale(self,factor):\n for x in range(len(self.coord)):\n self.coord[x] = np.array([y*factor for y in self.coord[x]])\n return self","def scale(self):","def scale(self, sf):\n self.scale(sf, sf)","def scale(self, factor):\n return BSplineFunc(self.kvs, self.coeffs * factor)","def generate(self, n):\n num_variables = len(self.xmin)\n\n # Generate in [0,1] space\n x = np.random.rand(n, num_variables)\n\n # Scale from [0,1] to [self.xmin, self.xmax]\n x_scaled = self.scale_to_new_domain(x, self.xmin, self.xmax)\n if self.use_logger:\n self.logger.info(\"Random design: generated {0} points in {1} dimensions\".format(n, num_variables))\n return x_scaled","def random_scale(img_scales, mode='range'):\n num_scales = len(img_scales)\n if num_scales == 1: # fixed scale is specified\n img_scale = img_scales[0]\n elif num_scales == 2: # randomly sample a scale\n if mode == 'range':\n ratio=max(img_scales[0])/min(img_scales[0])\n img_scale_long = [max(s) for s in img_scales]\n img_scale_short = [min(s) for s in img_scales]\n long_edge = np.random.randint(\n min(img_scale_long),\n max(img_scale_long) + 1)\n \"\"\"\n short_edge = np.random.randint(\n min(img_scale_short),\n max(img_scale_short) + 1)\n \"\"\"\n short_edge = int(long_edge/ratio) \n img_scale = (long_edge, short_edge)\n elif mode == 'value':\n img_scale = img_scales[np.random.randint(num_scales)]\n else:\n if mode != 'value':\n raise ValueError('Only \"value\" mode supports more than 2 image scales')\n img_scale = img_scales[np.random.randint(num_scales)]\n return img_scale","def get_scale():\r\n\r\n \r\n return 0.5","def scale(self, scale_factor: float) -> None:\n self.tensor[:, :3] *= scale_factor","def random_plane_points(num_points, bounds):\n\n # Infer dimension of data from bounds\n (bounds, dimension) = infer_dimension(bounds)\n\n # Generate points and rescale to fit bounds\n points = np.random.rand(num_points, dimension)\n unit_mean = [0.5] * dimension\n shifted_points = points - unit_mean + bounds.mean(axis=1)\n scale = bounds[:, 1] - bounds[:, 0]\n rescaled_points = np.dot(shifted_points, np.diag(scale))\n\n return rescaled_points","def scale_point_cloud(batch_data, batch_label):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n scale_num = np.random.uniform() * 5\n rotation_matrix = np.array([[scale_num, 0, 0],\n [0, scale_num, 0],\n [0, 0, scale_num]])\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\n \n return rotated_data, rotated_label","def scale_image(self, pixels, size):\n x_min, x_max = np.amin(pixels[:,0]), np.amax(pixels[:,0])\n y_min, y_max = np.amin(pixels[:,1]), np.amax(pixels[:,1])\n z_min, z_max = np.amin(pixels[:,2]), np.amax(pixels[:,2])\n \n pixels[:,0] -= x_min \n pixels[:,1] -= y_min\n pixels[:,2] -= z_min\n \n x_max -= x_min\n y_max -= y_min\n z_max -= z_min\n \n scale_factor = size / max(x_max, y_max, z_max) \n # All points are now between [0..max]\n\n pixels *= scale_factor\n return pixels","def apply_scale( vertices, scale=1.0 ):\n checkVerticesValidity( vertices )\n if type(scale) != float:\n raise ValueError\n \n for i in range(len(vertices)):\n v = vertices[i]\n tmpv = [v[0]*scale, v[1]*scale, v[2]*scale]\n vertices[i] = tmpv","def resample_voting_weights(self, loc, scale):\n\n for j in range(self.n_classifiers):\n for c in range(self.n_classes):\n self.voting_weights[j][c] = np.clip(\n np.random.normal(loc=loc[j][c], scale=scale),\n a_min=0., a_max=1.\n )\n\n return self","def scale(self, scale=1):\n self.x *= scale\n self.y *= scale\n self.width *= scale\n self.height *= scale\n\n # Always update the corners after operation\n self.update_corners()\n return","def scale(self, scale):\n\n self._scale = scale","def scale(self, scale):\n\n self._scale = scale","def scale_set(train,test):\n sc = StandardScaler()\n fitted = sc.fit(train)\n return sc.transform(train), sc.transform(test)","def test_scaling():\n rng = np.random.RandomState(42)\n shape = (400, 10)\n u = rng.standard_normal(size=shape)\n mean = 100 * rng.uniform(size=shape[1]) + 1\n Y = u + mean\n Y_, mean_ = mean_scaling(Y)\n assert_almost_equal(Y_.mean(0), 0, 5)\n assert_almost_equal(mean_, mean, 0)\n assert Y.std() > 1","def keypoints_scale(keypoints, scale_x, scale_y):\n keypoints[:, :2] = keypoints[:, :2] * (scale_x, scale_y)\n return keypoints","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def scale(x, feature_range=(-1, 1)):\n \n # scale from 0-1 to feature_range\n min, max = feature_range\n #x = x * (max - min) + min\n #x = torch.add(torch.mul(x, (max-min)), min)\n x = x.mul(max-min).add_(min)\n return x","def __init__(self, scale=0.1, rng=None):\n if rng is None:\n self.rng = np.random.RandomState(np.random.randint(0, 10000))\n else:\n self.rng = rng\n self.scale = scale","def _point_scale(self, width=None, height=None, scale=None):\n if numpy.count_nonzero([width is not None, height is not None, scale is not None]) > 1:\n raise ValueError(\"Specify only one of width, height, or scale.\")\n\n if width is not None:\n scale = toyplot.units.points(width) / self._width\n elif height is not None:\n scale = toyplot.units.points(height) / self._height\n elif scale is None:\n scale = 1.0\n return scale","def _scale_features(self, features):\n assert isinstance(features, np.ndarray), \"Input is not a numpy array!\"\n\n return self.scaler.transform(features.reshape(1, -1))","def reroll(self):\n self._base_x = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._x_min,\n self.base_point_distribution._x_max\n )\n self._base_y = tf.random.uniform(\n (self._sample_count,),\n self.base_point_distribution._y_min,\n self.base_point_distribution._y_max\n )","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def scale_in(self, count):\n pass","def scale(self, columns):\n self.verify_columns_in_dataset(columns)\n\n for col in columns:\n # First ensure the column has not already been scaled.\n if col in self.scalers:\n scaler, scaled = self.scalers[col]\n else:\n scaler = preprocessing.StandardScaler()\n scaled = False\n\n if not scaled:\n self.scalers[col] = (scaler, True)\n self.train.loc[:, col] = scaler.fit_transform(self.train[[col]])\n self.test.loc[:, col] = scaler.transform(self.test[[col]])","def scale_(entropy):\n\n # Double scale with each successive 1.\n bit_depth = 0\n while entropy(1):\n bit_depth += 1\n\n # Return a random number within the scale.\n return 2 ** bit_depth + entropy(bit_depth) - 1","def scale(self, X_train, X_test):\n\n #X_train, X_test, y_train, y_test = self.split_X_y_sets()\n self.scaler.fit(X_train)\n X_train_sc = self.scaler.transform(X_train)\n X_test_sc = self.scaler.transform(X_test)\n\n return X_train_sc, X_test_sc #, y_train, y_test","def scale(x, feature_range=(-1,1)):\r\n x = x * 2 - 1\r\n return x","def scale(self, scale):\n \n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\n self.transform(scale_matrix)","def scale(self, columns):\n self.verify_columns_in_dataset(columns)\n\n for col in columns:\n # First ensure the column has not already been scaled.\n if col in self.scalers:\n scaler, scaled = self.scalers[col]\n else:\n scaler = preprocessing.StandardScaler()\n scaled = False\n\n if not scaled:\n self.scalers[col] = (scaler, True)\n self.dataset[col] = scaler.fit_transform(self.dataset[[col]])","def scaling():\n \n for i in range(cfg.nfea):\n dm = 0\n var = 0\n for j in range(cfg.ntrain):\n dm += cfg.a[j,i]\n dm = dm/cfg.ntrain\n \n for j in range(cfg.ntrain):\n var += (cfg.a[j,i]-dm)**2\n\n var = var/cfg.ntrain\n var = np.sqrt(var)\n \n if var >= 10**(-5):\n cfg.clin[i] = 1.0/var \n cfg.dlin[i] = -dm/var \n \n else: \n if np.abs(dm)<=1.0:\n cfg.clin[i] = 1.0\n cfg.dlin[i] = 0.0 \n else: \n cfg.clin[i] = 1.0/dm\n cfg.dlin[i] = 0.0 \n \n for j in range(cfg.ntrain):\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\n \n return","def compute(self):\n # get the parameter values from the widgets\n loc = float(str(self.loctext.text()))\n scale = float(str(self.scaletext.text()))\n # check the values\n # compute\n self.data[2] = self.data[1] + np.random.normal(loc, scale, self.npt)\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.1\n # store the values\n self.loc = loc\n self.scale = scale\n self.updatePlot()","def _force_rescale(self, setpoint_x, setpoint_y):","def resampleParticles(self, gameState):\n self.particles = []\n for i in range(self.numParticles):\n self.particles.append(tuple(util.sample(self.uniformPrior) for _ in\n self.ghostIndices))","def random_zoom(x, zoom_range, row_axis=1, col_axis=2, channel_axis=0,\n fill_mode='nearest', cval=0.):\n if len(zoom_range) != 2:\n raise ValueError('`zoom_range` should be a tuple or list of two floats. '\n 'Received arg: ', zoom_range)\n\n if zoom_range[0] == 1 and zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)\n zoom_matrix = np.array([[zx, 0, 0],\n [0, zy, 0],\n [0, 0, 1]])\n\n h, w = x.shape[row_axis], x.shape[col_axis]\n transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\n return x","def parallel_scale(self, value):\n self.camera.parallel_scale = value\n self.Modified()","def _sample_using_random(\n self,\n p: float = 0.1,\n ):\n return sa.func.random() < p","def scale(self, scale_x: float, scale_y: float) -> None:\n self.tensor[:, 0::2] *= scale_x\n self.tensor[:, 1::2] *= scale_y","def randomPointOnSphere(r):\n x = np.random.normal()\n y = np.random.normal()\n z = np.random.normal()\n point = np.array([x, y, z])\n point *= r/(x**2 + y**2 + z**2)**.5\n return point","def __scale(data, max_value_list, min_value_list, scale_value_list, process_cols_list):\n features = np.array(data.features, dtype=float)\n for i in process_cols_list:\n value = features[i]\n if value > max_value_list[i]:\n value = max_value_list[i]\n elif value < min_value_list[i]:\n value = min_value_list[i]\n\n features[i] = (value - min_value_list[i]) / scale_value_list[i]\n _data = copy.deepcopy(data)\n _data.features = features\n return _data","def sample_new_observations(self, point, n_samples, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n\n posterior_parameters = self.compute_posterior_parameters(point)\n mean = posterior_parameters['mean']\n var = posterior_parameters['cov']\n\n samples = np.random.normal(mean[0], np.sqrt(var[0, 0]), n_samples)\n\n return samples","def _scale(self, normalize, mat):\n mat = mat.astype(float)\n if normalize:\n mat = sklearn_norm(mat,\n feature_range=(0, 1),\n axis=0,\n copy=True)\n else:\n return mat\n return mat","def generate_points(rng: RNG, number_of_points, dimension, scale=1.0) -> np.array:\n\n # points = []\n # for _ in range(self.number_of_points):\n # point = []\n # for _ in range(self.dimension):\n # value = rng.next_float()\n # while value > self.scale:\n # value = rng.next_float()\n # point.append(value)\n # points.append(points)\n # return np.array(points)\n\n # function to generate a point.\n def generate_point(i, j):\n # i and j are required for np.fromfunction, but not used.\n del i, j\n value = rng.next_float()\n while value > scale:\n value = rng.next_float()\n return value\n\n # Then creates the array using said function.\n return np.fromfunction(np.vectorize(generate_point), (number_of_points, dimension))","def scale(self, alpha):\n\t\tc = SparseVector(self.d)\n\t\tfor i in self.st.keys():\n\t\t\tc.put(i, alpha*self.get(i))\n\t\treturn c","def rand_scale_log_normal(mean_scale, one_sigma_at_scale):\n\n log_sigma = math.log(one_sigma_at_scale)\n return mean_scale*math.exp(random.normalvariate(0.0, log_sigma))","def scale(self, data: np.ndarray):\n if self.scale_type == \"min_max\":\n scaled_data = (data - self.predictor_min) / (\n self.predictor_max - self.predictor_mean\n )\n elif self.scale_type == \"normalize\":\n scaled_data = (data - self.predictor_mean) / (\n self.predictor_max - self.predictor_min\n )\n elif self.scale_type == \"standardize\":\n scaled_data = (data - self.predictor_mean) / self.predictor_std\n elif self.scale_type == \"scale\":\n scaled_data = data - self.predictor_mean\n else:\n scaled_data = data\n return scaled_data","def setScale(self, *args):\n return _libsbml.Unit_setScale(self, *args)","def post(self, s):\n return np.random.choice(self.sample_list)","def normalize_particles(self):\n tot_weight = sum([particle.w for particle in self.particle_cloud]) or 1\n for particle in self.particle_cloud:\n particle.w = particle.w / tot_weight;","def scaleAll(self, scale):\n center = [self.width/2, self.height/2, 0, 0]\n matrix = self.scaleMatrix(scale, scale, scale)\n\n for wireframe in self.wireframes.values():\n wireframe.scale(center, matrix)","def scale(self):\n return self._scale","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def getScale(self):\n return self.factor**self.turnOn","def __call__(self, batch: base.Batch, key: base.RngKey) -> base.Array:\n return jax.random.normal(key, batch.x.shape) * self.scale","def point_sample_fine_grained_features(features_list, feature_scales, boxes, point_coords):\n cat_boxes = Boxes.cat(boxes)\n num_boxes = [len(b) for b in boxes]\n\n point_coords_wrt_image = get_point_coords_wrt_image(cat_boxes.tensor, point_coords)\n split_point_coords_wrt_image = torch.split(point_coords_wrt_image, num_boxes)\n\n point_features = []\n for idx_img, point_coords_wrt_image_per_image in enumerate(split_point_coords_wrt_image):\n point_features_per_image = []\n for idx_feature, feature_map in enumerate(features_list):\n h, w = feature_map.shape[-2:]\n scale = torch.tensor([w, h], device=feature_map.device) / feature_scales[idx_feature]\n point_coords_scaled = point_coords_wrt_image_per_image / scale\n point_features_per_image.append(\n point_sample(\n feature_map[idx_img].unsqueeze(0),\n point_coords_scaled.unsqueeze(0),\n align_corners=False,\n )\n .squeeze(0)\n .transpose(1, 0)\n )\n point_features.append(cat(point_features_per_image, dim=1))\n\n return cat(point_features, dim=0), point_coords_wrt_image","def random_zoom(x, zoom_range, row_axis=0, col_axis=1, channel_axis=2,\n fill_mode='nearest', cval=0., interpolation_order=1):\n if len(zoom_range) != 2:\n raise ValueError('`zoom_range` should be a tuple or list of two'\n ' floats. Received: %s' % (zoom_range,))\n\n if zoom_range[0] == 1 and zoom_range[1] == 1:\n zx, zy = 1, 1\n else:\n zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)\n x = apply_affine_transform(x, zx=zx, zy=zy, channel_axis=channel_axis,\n fill_mode=fill_mode, cval=cval,\n order=interpolation_order)\n return x","def realize(self):\n if numpy.random.rand() > self._P:\n self._w *= 0.0","def scale_and_translate_points(points):\n x = points[0]\n y = points[1]\n center = points.mean(axis=1) # mean of each row\n cx = x - center[0] # center the points\n cy = y - center[1]\n dist = np.sqrt(np.power(cx, 2) + np.power(cy, 2))\n scale = np.sqrt(2) / dist.mean()\n norm3d = np.array([\n [scale, 0, -scale * center[0]],\n [0, scale, -scale * center[1]],\n [0, 0, 1]\n ])\n\n return np.dot(norm3d, points), norm3d","def random_point(self, n_samples=1, bound=1.0):\n samples = self._iterate_over_factors(\n \"random_point\", {\"n_samples\": n_samples, \"bound\": bound}\n )\n return samples","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def scale_model_input(self, sample: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:\n return sample"],"string":"[\n \"def scale_point_cloud(batch_data, scale_ratio=0.8):\\n B, N, C = batch_data.shape\\n scale = np.random.uniform(scale_ratio,1/scale_ratio,(B,1,1))\\n scaled_data = batch_data*scale\\n return scaled_data\",\n \"def ScalePoints(points, sigma = 0.02):\\n assert(points.shape[1]==3)\\n\\n scale = np.random.uniform(1-sigma, 1+sigma)\\n scale_matrix = np.array([[scale, 0, 0],\\n [0, scale, 0],\\n [0, 0, scale]])\\n scaled = np.dot(points, scale_matrix)\\n\\n return scaled\",\n \"def _random_scale(self, results):\\n # For multi-scale training\\n shuffle(self.img_scale)\\n \\n if self.multiscale_mode == 'range':\\n scale, scale_idx = self.random_sample_ratio(\\n self.img_scale[0], self.ratio_range, self.ratio_hr_lr)\\n elif self.multiscale_mode == 'value':\\n scale, scale_idx = self.random_select_ratio(self.img_scale[0], self.ratio_range, self.ratio_hr_lr)\\n else:\\n raise NotImplementedError\\n\\n results['scale'] = scale\\n results['scale_idx'] = scale_idx\",\n \"def resample_particles(self):\\n # make sure the distribution is normalized\\n self.normalize_particles()\\n\\n newParticles = []\\n for i in range(len(self.particle_cloud)):\\n # resample the same # of particles\\n choice = random_sample()\\n # all the particle weights sum to 1\\n csum = 0 # cumulative sum\\n for particle in self.particle_cloud:\\n csum += particle.w\\n if csum >= choice:\\n # if the random choice fell within the particle's weight\\n newParticles.append(deepcopy(particle))\\n break\\n self.particle_cloud = newParticles\",\n \"def _random_scale(self, results):\\n\\n if self.ratio_range is not None:\\n scale, scale_idx = self.random_sample_ratio(\\n self.img_scale[0], self.ratio_range)\\n elif len(self.img_scale) == 1:\\n scale, scale_idx = self.img_scale[0], 0\\n elif self.multiscale_mode == 'range':\\n scale, scale_idx = self.random_sample(self.img_scale)\\n elif self.multiscale_mode == 'value':\\n scale, scale_idx = self.random_select(self.img_scale)\\n else:\\n raise NotImplementedError\\n\\n results['scale'] = scale\\n results['scale_idx'] = scale_idx\",\n \"def _getScalesRand(self):\\n if self.P > 1:\\n scales = []\\n for term_i in range(self.n_randEffs):\\n _scales = sp.randn(self.diag[term_i].shape[0])\\n if self.jitter[term_i] > 0:\\n _scales = sp.concatenate(\\n (_scales, sp.array([sp.sqrt(self.jitter[term_i])])))\\n scales.append(_scales)\\n scales = sp.concatenate(scales)\\n else:\\n scales = sp.randn(self.vd.getNumberScales())\\n return scales\",\n \"def _random_scale(self, waveform, prob):\\n # Get random true or false\\n prediction = self._random_true_false(prob=prob)\\n\\n # Apply random multiplication factor\\n waveform = tf.cond(prediction, lambda: self._scale(waveform=waveform),\\n lambda: self._do_nothing(waveform=waveform))\\n\\n return waveform\",\n \"def _scale(waveform):\\n # Get random scale factor\\n scale_factor = tf.random_uniform(shape=[], minval=0.5, maxval=2.5, dtype=tf.float32)\\n\\n return waveform * scale_factor\",\n \"def perturb_point(self, x, scale):\\n x_samp = x + (scale / 2.0) * (np.random.rand(3) - 0.5)\\n return x_samp\",\n \"def scale(self, points, inplace=True):\\n points = np.array(points).astype(float)\\n if inplace==False:\\n points = points.copy()\\n # if len(points.shape) == 1:\\n # points = points[None,:]\\n # if len(points.shape) != 2:\\n # logger.error(\\\"cannot scale array of dimensions\\\".format(len(points.shape)))\\n points -= self.origin\\n points /= self.scale_factor\\n return points\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def scale(self,scale_by):\\n x = self._x * scale_by\\n y = self._y * scale_by\\n return Point(x,y)\",\n \"def ScaleShape(shape, scale_x, scale_y):\\n for i, pt in enumerate(shape.points):\\n x, y = pt\\n shape.points[i] = [scale_x * x, scale_y * y]\",\n \"def scale(self, scale):\\n\\t\\tself._current_score *= scale\",\n \"def scale(self, scale):\\n self.coords = self.coords * scale\\n return self\",\n \"def random_scale(imgs, DIFFICULTY):\\n MULTIPLY_SCALES = [\\n [1, 1],\\n [0.9, 1.1],\\n [0.85, 1.15],\\n [0.8, 1.2],\\n [0.75, 1.25],\\n [0.7, 1.3],\\n [0.65, 1.325],\\n [0.6, 1.35],\\n [0.55, 1.375],\\n [0.50, 1.4],\\n [0.48, 1.42],\\n [0.46, 1.44],\\n [0.44, 1.46],\\n [0.42, 1.48],\\n [0.4, 1.5],\\n [0.35, 1.6],\\n ]\\n channels = imgs.shape[-1]\\n scales = tf.gather(MULTIPLY_SCALES, DIFFICULTY)\\n scales = tf.random.uniform([channels], minval=scales[0], maxval=scales[1])\\n imgs = imgs * scales\\n return imgs\",\n \"def set_training_random_scale_factors(self, scale_min, scale_max):\\n # Select a random scale factor.\\n random_scale_factor = tf.random_uniform([], scale_min, scale_max)\\n scaled_size = tf.to_int32(random_scale_factor * self._output_size)\\n\\n # Recompute the accurate scale_factor using rounded scaled image size.\\n height = tf.shape(self._image)[0]\\n width = tf.shape(self._image)[1]\\n max_image_size = tf.to_float(tf.maximum(height, width))\\n image_scale = tf.to_float(scaled_size) / max_image_size\\n\\n # Select non-zero random offset (x, y) if scaled image is larger than\\n # self._output_size.\\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\\n offset_y = tf.to_float(scaled_height - self._output_size)\\n offset_x = tf.to_float(scaled_width - self._output_size)\\n offset_y = tf.maximum(0.0, offset_y) * tf.random_uniform([], 0, 1)\\n offset_x = tf.maximum(0.0, offset_x) * tf.random_uniform([], 0, 1)\\n offset_y = tf.to_int32(offset_y)\\n offset_x = tf.to_int32(offset_x)\\n self._image_scale = image_scale\\n self._scaled_height = scaled_height\\n self._scaled_width = scaled_width\\n self._crop_offset_x = offset_x\\n self._crop_offset_y = offset_y\",\n \"def scale_data_point(self, data_point):\\n \\n data_point_scaled = pd.Series(self.scaler.transform(data_point[self.feature_names].to_numpy().reshape(1, -1)).ravel())\\n data_point_scaled.name = data_point.name\\n data_point_scaled.index = self.feature_names\\n \\n # Set any values > 1 to 1. This is only used in visualization.\\n data_point_scaled = data_point_scaled.where(data_point_scaled <= 1.0, 1.0)\\n #data_point_scaled.values = data_point_scaled.values.apply(> 1.0 else 1.0 for y in x])\\n\\n return data_point_scaled\",\n \"def mutate(self, size):\\n rand = random.random()\\n if rand <= 0.5:\\n print u\\\"changing colour\\\"\\n idx = random.randrange(0, 4)\\n value = random.randrange(0, 256)\\n colour = list(self.colour)\\n colour[idx] = value\\n self.colour = tuple(colour)\\n else:\\n print u\\\"changing point\\\"\\n idx = random.randrange(0, len(self.points))\\n point = generate_point(size[0], size[1])\\n self.points[idx] = point\",\n \"def test_set_scale():\\n data = io.create_sample_Dataset()\\n tmp = data.piv.set_scale(1.0)\\n assert np.allclose(tmp[\\\"x\\\"], data[\\\"x\\\"])\\n\\n tmp = data.copy()\\n tmp.piv.set_scale(2.0)\\n tmp_mean = tmp[\\\"u\\\"].mean(dim=(\\\"t\\\", \\\"x\\\", \\\"y\\\")).values\\n data_mean = data[\\\"u\\\"].mean(dim=(\\\"t\\\", \\\"x\\\", \\\"y\\\")).values\\n assert np.allclose(tmp_mean / data_mean, 2.0)\",\n \"def random_transform(self, x, seed=None):\\n # x is a single audio, so it doesn't have image number at index 0\\n img_row_axis = self.row_axis - 1\\n img_channel_axis = self.channel_axis - 1\\n\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if not (self.zoom_range[0] == 1 and self.zoom_range[1] == 1):\\n zx = np.random.uniform(self.zoom_range[0], self.zoom_range[1])\\n input_length = x.shape[img_row_axis]\\n x = resample(x, num=int(zx * x.shape[img_row_axis]), axis=img_row_axis)\\n if x.shape[img_row_axis] >= input_length:\\n x = x[:input_length]\\n else:\\n x = np.pad(x, ((0, input_length - x.shape[img_row_axis]), (0, 0)),\\n 'constant', constant_values=(0, np.mean(x)))\\n\\n if shift:\\n hx = np.random.uniform(-self.shift, self.shift)\\n x = shift(x, (int(hx * x.shape[img_row_axis]), 0), mode=self.fill_mode, cval=self.cval)\\n\\n if self.roll_range:\\n tx = np.random.uniform(-self.roll_range, self.roll_range)\\n if self.roll_range < 1:\\n tx *= x.shape[img_row_axis]\\n x = np.roll(x, int(tx), axis=(img_row_axis))\\n\\n if self.horizontal_flip:\\n if np.random.random() < 0.5:\\n x = np.flip(x, axis=img_row_axis)\\n\\n if (self.noise):\\n if np.random.random() < 0.5:\\n if self.noise[-1] == 'Uniform':\\n x = x + np.random.uniform(self.noise[0], self.noise[1], size=x.shape)\\n elif self.noise[-1] == 'Normal':\\n x = x + np.random.normal(self.noise[0], self.noise[1], size=x.shape)\\n\\n if self.brightness_range is not None:\\n x = random_brightness(x, self.brightness_range)\\n\\n return x\",\n \"def scale_uniform(self, s: float):\\n self.vertices = [v * s for v in self.vertices]\\n return self\",\n \"def rescale(self, points, inplace=True):\\n if inplace == False:\\n points = points.copy()\\n points *= self.scale_factor\\n points += self.origin\\n return points\",\n \"def random_subsample(cloud, sample_size, replace=False):\\n\\n # Handle small point clouds\\n if cloud.shape[0] <= sample_size:\\n warn(\\\"(code 1) Point cloud is already <= desired sample size. \\\" +\\n \\\"No subsampling is performed.\\\")\\n return cloud\\n\\n # Perform subsamping\\n sample_indices = np.random.choice(np.arange(cloud.shape[0]),\\n sample_size, replace=False)\\n cloud_subs = cloud[sample_indices]\\n\\n # Return result\\n return cloud_subs\",\n \"def scale(x, p=2, inplace=False):\\n return x / np.linalg.norm(x, ord=p)\",\n \"def scale(self,s):\\n return Vector(self.x * s, self.y * s, self.z * s)\",\n \"def scale(self, factor):\\n new = self.copy()\\n new.d.clear()\\n\\n for val, prob in self.items():\\n new.set(val * factor, prob)\\n return new\",\n \"def scale_point(point, centroid, scale):\\n point = np.asarray(point)\\n centroid = centroid[:2]\\n vector = ((point - centroid)*scale) + centroid\\n return vector\",\n \"def random_transform(self, x):\\n pass\",\n \"def scale(self, size=128):\\n scale_factor = size / max(self.voxels.shape)\\n self.voxels = ndimage.zoom(self.voxels, scale_factor)\\n self.point_position = self.point_position * scale_factor\\n self.voxel_size = False # To ignore this\\n \\n return(self)\",\n \"def scale(x_range=1, y_range=1):\\r\\n x = rand_val(x_range)\\r\\n y = rand_val(y_range)\\r\\n return np.array(((x, 0, 0),\\r\\n (0, y, 0),\\r\\n (0, 0, 1)), dtype=np.float)\",\n \"def scale(self, x, y, z) -> None:\\n ...\",\n \"def scale(self, factor: float) -> Point:\\n return Point(self.x * factor, self.y * factor)\",\n \"def scale(self, sc):\\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\\n return self\",\n \"def format_point_cloud(self, pc, num_points):\\n resized_pc = np.zeros([num_points, 3])\\n if len(pc) > num_points:\\n # Randomly sample point cloud to reduce size\\n resized_pc = pc[np.random.choice(pc.shape[0], num_points,\\n replace=False), :]\\n elif len(pc) < num_points:\\n # Duplicate last point to fill point cloud. Because of the max function\\n # the duplicated points will not affect the output\\n resized_pc[:len(pc)] = pc\\n resized_pc[len(pc):] = pc[-1]\\n else:\\n resized_pc = pc\\n\\n return resized_pc\",\n \"def scale(self,factor):\\n for x in range(len(self.coord)):\\n self.coord[x] = np.array([y*factor for y in self.coord[x]])\\n return self\",\n \"def scale(self):\",\n \"def scale(self, sf):\\n self.scale(sf, sf)\",\n \"def scale(self, factor):\\n return BSplineFunc(self.kvs, self.coeffs * factor)\",\n \"def generate(self, n):\\n num_variables = len(self.xmin)\\n\\n # Generate in [0,1] space\\n x = np.random.rand(n, num_variables)\\n\\n # Scale from [0,1] to [self.xmin, self.xmax]\\n x_scaled = self.scale_to_new_domain(x, self.xmin, self.xmax)\\n if self.use_logger:\\n self.logger.info(\\\"Random design: generated {0} points in {1} dimensions\\\".format(n, num_variables))\\n return x_scaled\",\n \"def random_scale(img_scales, mode='range'):\\n num_scales = len(img_scales)\\n if num_scales == 1: # fixed scale is specified\\n img_scale = img_scales[0]\\n elif num_scales == 2: # randomly sample a scale\\n if mode == 'range':\\n ratio=max(img_scales[0])/min(img_scales[0])\\n img_scale_long = [max(s) for s in img_scales]\\n img_scale_short = [min(s) for s in img_scales]\\n long_edge = np.random.randint(\\n min(img_scale_long),\\n max(img_scale_long) + 1)\\n \\\"\\\"\\\"\\n short_edge = np.random.randint(\\n min(img_scale_short),\\n max(img_scale_short) + 1)\\n \\\"\\\"\\\"\\n short_edge = int(long_edge/ratio) \\n img_scale = (long_edge, short_edge)\\n elif mode == 'value':\\n img_scale = img_scales[np.random.randint(num_scales)]\\n else:\\n if mode != 'value':\\n raise ValueError('Only \\\"value\\\" mode supports more than 2 image scales')\\n img_scale = img_scales[np.random.randint(num_scales)]\\n return img_scale\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def scale(self, scale_factor: float) -> None:\\n self.tensor[:, :3] *= scale_factor\",\n \"def random_plane_points(num_points, bounds):\\n\\n # Infer dimension of data from bounds\\n (bounds, dimension) = infer_dimension(bounds)\\n\\n # Generate points and rescale to fit bounds\\n points = np.random.rand(num_points, dimension)\\n unit_mean = [0.5] * dimension\\n shifted_points = points - unit_mean + bounds.mean(axis=1)\\n scale = bounds[:, 1] - bounds[:, 0]\\n rescaled_points = np.dot(shifted_points, np.diag(scale))\\n\\n return rescaled_points\",\n \"def scale_point_cloud(batch_data, batch_label):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n scale_num = np.random.uniform() * 5\\n rotation_matrix = np.array([[scale_num, 0, 0],\\n [0, scale_num, 0],\\n [0, 0, scale_num]])\\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\\n \\n return rotated_data, rotated_label\",\n \"def scale_image(self, pixels, size):\\n x_min, x_max = np.amin(pixels[:,0]), np.amax(pixels[:,0])\\n y_min, y_max = np.amin(pixels[:,1]), np.amax(pixels[:,1])\\n z_min, z_max = np.amin(pixels[:,2]), np.amax(pixels[:,2])\\n \\n pixels[:,0] -= x_min \\n pixels[:,1] -= y_min\\n pixels[:,2] -= z_min\\n \\n x_max -= x_min\\n y_max -= y_min\\n z_max -= z_min\\n \\n scale_factor = size / max(x_max, y_max, z_max) \\n # All points are now between [0..max]\\n\\n pixels *= scale_factor\\n return pixels\",\n \"def apply_scale( vertices, scale=1.0 ):\\n checkVerticesValidity( vertices )\\n if type(scale) != float:\\n raise ValueError\\n \\n for i in range(len(vertices)):\\n v = vertices[i]\\n tmpv = [v[0]*scale, v[1]*scale, v[2]*scale]\\n vertices[i] = tmpv\",\n \"def resample_voting_weights(self, loc, scale):\\n\\n for j in range(self.n_classifiers):\\n for c in range(self.n_classes):\\n self.voting_weights[j][c] = np.clip(\\n np.random.normal(loc=loc[j][c], scale=scale),\\n a_min=0., a_max=1.\\n )\\n\\n return self\",\n \"def scale(self, scale=1):\\n self.x *= scale\\n self.y *= scale\\n self.width *= scale\\n self.height *= scale\\n\\n # Always update the corners after operation\\n self.update_corners()\\n return\",\n \"def scale(self, scale):\\n\\n self._scale = scale\",\n \"def scale(self, scale):\\n\\n self._scale = scale\",\n \"def scale_set(train,test):\\n sc = StandardScaler()\\n fitted = sc.fit(train)\\n return sc.transform(train), sc.transform(test)\",\n \"def test_scaling():\\n rng = np.random.RandomState(42)\\n shape = (400, 10)\\n u = rng.standard_normal(size=shape)\\n mean = 100 * rng.uniform(size=shape[1]) + 1\\n Y = u + mean\\n Y_, mean_ = mean_scaling(Y)\\n assert_almost_equal(Y_.mean(0), 0, 5)\\n assert_almost_equal(mean_, mean, 0)\\n assert Y.std() > 1\",\n \"def keypoints_scale(keypoints, scale_x, scale_y):\\n keypoints[:, :2] = keypoints[:, :2] * (scale_x, scale_y)\\n return keypoints\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def scale(x, feature_range=(-1, 1)):\\n \\n # scale from 0-1 to feature_range\\n min, max = feature_range\\n #x = x * (max - min) + min\\n #x = torch.add(torch.mul(x, (max-min)), min)\\n x = x.mul(max-min).add_(min)\\n return x\",\n \"def __init__(self, scale=0.1, rng=None):\\n if rng is None:\\n self.rng = np.random.RandomState(np.random.randint(0, 10000))\\n else:\\n self.rng = rng\\n self.scale = scale\",\n \"def _point_scale(self, width=None, height=None, scale=None):\\n if numpy.count_nonzero([width is not None, height is not None, scale is not None]) > 1:\\n raise ValueError(\\\"Specify only one of width, height, or scale.\\\")\\n\\n if width is not None:\\n scale = toyplot.units.points(width) / self._width\\n elif height is not None:\\n scale = toyplot.units.points(height) / self._height\\n elif scale is None:\\n scale = 1.0\\n return scale\",\n \"def _scale_features(self, features):\\n assert isinstance(features, np.ndarray), \\\"Input is not a numpy array!\\\"\\n\\n return self.scaler.transform(features.reshape(1, -1))\",\n \"def reroll(self):\\n self._base_x = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._x_min,\\n self.base_point_distribution._x_max\\n )\\n self._base_y = tf.random.uniform(\\n (self._sample_count,),\\n self.base_point_distribution._y_min,\\n self.base_point_distribution._y_max\\n )\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def scale_in(self, count):\\n pass\",\n \"def scale(self, columns):\\n self.verify_columns_in_dataset(columns)\\n\\n for col in columns:\\n # First ensure the column has not already been scaled.\\n if col in self.scalers:\\n scaler, scaled = self.scalers[col]\\n else:\\n scaler = preprocessing.StandardScaler()\\n scaled = False\\n\\n if not scaled:\\n self.scalers[col] = (scaler, True)\\n self.train.loc[:, col] = scaler.fit_transform(self.train[[col]])\\n self.test.loc[:, col] = scaler.transform(self.test[[col]])\",\n \"def scale_(entropy):\\n\\n # Double scale with each successive 1.\\n bit_depth = 0\\n while entropy(1):\\n bit_depth += 1\\n\\n # Return a random number within the scale.\\n return 2 ** bit_depth + entropy(bit_depth) - 1\",\n \"def scale(self, X_train, X_test):\\n\\n #X_train, X_test, y_train, y_test = self.split_X_y_sets()\\n self.scaler.fit(X_train)\\n X_train_sc = self.scaler.transform(X_train)\\n X_test_sc = self.scaler.transform(X_test)\\n\\n return X_train_sc, X_test_sc #, y_train, y_test\",\n \"def scale(x, feature_range=(-1,1)):\\r\\n x = x * 2 - 1\\r\\n return x\",\n \"def scale(self, scale):\\n \\n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\\n self.transform(scale_matrix)\",\n \"def scale(self, columns):\\n self.verify_columns_in_dataset(columns)\\n\\n for col in columns:\\n # First ensure the column has not already been scaled.\\n if col in self.scalers:\\n scaler, scaled = self.scalers[col]\\n else:\\n scaler = preprocessing.StandardScaler()\\n scaled = False\\n\\n if not scaled:\\n self.scalers[col] = (scaler, True)\\n self.dataset[col] = scaler.fit_transform(self.dataset[[col]])\",\n \"def scaling():\\n \\n for i in range(cfg.nfea):\\n dm = 0\\n var = 0\\n for j in range(cfg.ntrain):\\n dm += cfg.a[j,i]\\n dm = dm/cfg.ntrain\\n \\n for j in range(cfg.ntrain):\\n var += (cfg.a[j,i]-dm)**2\\n\\n var = var/cfg.ntrain\\n var = np.sqrt(var)\\n \\n if var >= 10**(-5):\\n cfg.clin[i] = 1.0/var \\n cfg.dlin[i] = -dm/var \\n \\n else: \\n if np.abs(dm)<=1.0:\\n cfg.clin[i] = 1.0\\n cfg.dlin[i] = 0.0 \\n else: \\n cfg.clin[i] = 1.0/dm\\n cfg.dlin[i] = 0.0 \\n \\n for j in range(cfg.ntrain):\\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\\n \\n return\",\n \"def compute(self):\\n # get the parameter values from the widgets\\n loc = float(str(self.loctext.text()))\\n scale = float(str(self.scaletext.text()))\\n # check the values\\n # compute\\n self.data[2] = self.data[1] + np.random.normal(loc, scale, self.npt)\\n self.data[3] = self.data[2] - self.data[1] - self.dataSpan * 0.1\\n # store the values\\n self.loc = loc\\n self.scale = scale\\n self.updatePlot()\",\n \"def _force_rescale(self, setpoint_x, setpoint_y):\",\n \"def resampleParticles(self, gameState):\\n self.particles = []\\n for i in range(self.numParticles):\\n self.particles.append(tuple(util.sample(self.uniformPrior) for _ in\\n self.ghostIndices))\",\n \"def random_zoom(x, zoom_range, row_axis=1, col_axis=2, channel_axis=0,\\n fill_mode='nearest', cval=0.):\\n if len(zoom_range) != 2:\\n raise ValueError('`zoom_range` should be a tuple or list of two floats. '\\n 'Received arg: ', zoom_range)\\n\\n if zoom_range[0] == 1 and zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)\\n zoom_matrix = np.array([[zx, 0, 0],\\n [0, zy, 0],\\n [0, 0, 1]])\\n\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)\\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\\n return x\",\n \"def parallel_scale(self, value):\\n self.camera.parallel_scale = value\\n self.Modified()\",\n \"def _sample_using_random(\\n self,\\n p: float = 0.1,\\n ):\\n return sa.func.random() < p\",\n \"def scale(self, scale_x: float, scale_y: float) -> None:\\n self.tensor[:, 0::2] *= scale_x\\n self.tensor[:, 1::2] *= scale_y\",\n \"def randomPointOnSphere(r):\\n x = np.random.normal()\\n y = np.random.normal()\\n z = np.random.normal()\\n point = np.array([x, y, z])\\n point *= r/(x**2 + y**2 + z**2)**.5\\n return point\",\n \"def __scale(data, max_value_list, min_value_list, scale_value_list, process_cols_list):\\n features = np.array(data.features, dtype=float)\\n for i in process_cols_list:\\n value = features[i]\\n if value > max_value_list[i]:\\n value = max_value_list[i]\\n elif value < min_value_list[i]:\\n value = min_value_list[i]\\n\\n features[i] = (value - min_value_list[i]) / scale_value_list[i]\\n _data = copy.deepcopy(data)\\n _data.features = features\\n return _data\",\n \"def sample_new_observations(self, point, n_samples, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n\\n posterior_parameters = self.compute_posterior_parameters(point)\\n mean = posterior_parameters['mean']\\n var = posterior_parameters['cov']\\n\\n samples = np.random.normal(mean[0], np.sqrt(var[0, 0]), n_samples)\\n\\n return samples\",\n \"def _scale(self, normalize, mat):\\n mat = mat.astype(float)\\n if normalize:\\n mat = sklearn_norm(mat,\\n feature_range=(0, 1),\\n axis=0,\\n copy=True)\\n else:\\n return mat\\n return mat\",\n \"def generate_points(rng: RNG, number_of_points, dimension, scale=1.0) -> np.array:\\n\\n # points = []\\n # for _ in range(self.number_of_points):\\n # point = []\\n # for _ in range(self.dimension):\\n # value = rng.next_float()\\n # while value > self.scale:\\n # value = rng.next_float()\\n # point.append(value)\\n # points.append(points)\\n # return np.array(points)\\n\\n # function to generate a point.\\n def generate_point(i, j):\\n # i and j are required for np.fromfunction, but not used.\\n del i, j\\n value = rng.next_float()\\n while value > scale:\\n value = rng.next_float()\\n return value\\n\\n # Then creates the array using said function.\\n return np.fromfunction(np.vectorize(generate_point), (number_of_points, dimension))\",\n \"def scale(self, alpha):\\n\\t\\tc = SparseVector(self.d)\\n\\t\\tfor i in self.st.keys():\\n\\t\\t\\tc.put(i, alpha*self.get(i))\\n\\t\\treturn c\",\n \"def rand_scale_log_normal(mean_scale, one_sigma_at_scale):\\n\\n log_sigma = math.log(one_sigma_at_scale)\\n return mean_scale*math.exp(random.normalvariate(0.0, log_sigma))\",\n \"def scale(self, data: np.ndarray):\\n if self.scale_type == \\\"min_max\\\":\\n scaled_data = (data - self.predictor_min) / (\\n self.predictor_max - self.predictor_mean\\n )\\n elif self.scale_type == \\\"normalize\\\":\\n scaled_data = (data - self.predictor_mean) / (\\n self.predictor_max - self.predictor_min\\n )\\n elif self.scale_type == \\\"standardize\\\":\\n scaled_data = (data - self.predictor_mean) / self.predictor_std\\n elif self.scale_type == \\\"scale\\\":\\n scaled_data = data - self.predictor_mean\\n else:\\n scaled_data = data\\n return scaled_data\",\n \"def setScale(self, *args):\\n return _libsbml.Unit_setScale(self, *args)\",\n \"def post(self, s):\\n return np.random.choice(self.sample_list)\",\n \"def normalize_particles(self):\\n tot_weight = sum([particle.w for particle in self.particle_cloud]) or 1\\n for particle in self.particle_cloud:\\n particle.w = particle.w / tot_weight;\",\n \"def scaleAll(self, scale):\\n center = [self.width/2, self.height/2, 0, 0]\\n matrix = self.scaleMatrix(scale, scale, scale)\\n\\n for wireframe in self.wireframes.values():\\n wireframe.scale(center, matrix)\",\n \"def scale(self):\\n return self._scale\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def getScale(self):\\n return self.factor**self.turnOn\",\n \"def __call__(self, batch: base.Batch, key: base.RngKey) -> base.Array:\\n return jax.random.normal(key, batch.x.shape) * self.scale\",\n \"def point_sample_fine_grained_features(features_list, feature_scales, boxes, point_coords):\\n cat_boxes = Boxes.cat(boxes)\\n num_boxes = [len(b) for b in boxes]\\n\\n point_coords_wrt_image = get_point_coords_wrt_image(cat_boxes.tensor, point_coords)\\n split_point_coords_wrt_image = torch.split(point_coords_wrt_image, num_boxes)\\n\\n point_features = []\\n for idx_img, point_coords_wrt_image_per_image in enumerate(split_point_coords_wrt_image):\\n point_features_per_image = []\\n for idx_feature, feature_map in enumerate(features_list):\\n h, w = feature_map.shape[-2:]\\n scale = torch.tensor([w, h], device=feature_map.device) / feature_scales[idx_feature]\\n point_coords_scaled = point_coords_wrt_image_per_image / scale\\n point_features_per_image.append(\\n point_sample(\\n feature_map[idx_img].unsqueeze(0),\\n point_coords_scaled.unsqueeze(0),\\n align_corners=False,\\n )\\n .squeeze(0)\\n .transpose(1, 0)\\n )\\n point_features.append(cat(point_features_per_image, dim=1))\\n\\n return cat(point_features, dim=0), point_coords_wrt_image\",\n \"def random_zoom(x, zoom_range, row_axis=0, col_axis=1, channel_axis=2,\\n fill_mode='nearest', cval=0., interpolation_order=1):\\n if len(zoom_range) != 2:\\n raise ValueError('`zoom_range` should be a tuple or list of two'\\n ' floats. Received: %s' % (zoom_range,))\\n\\n if zoom_range[0] == 1 and zoom_range[1] == 1:\\n zx, zy = 1, 1\\n else:\\n zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)\\n x = apply_affine_transform(x, zx=zx, zy=zy, channel_axis=channel_axis,\\n fill_mode=fill_mode, cval=cval,\\n order=interpolation_order)\\n return x\",\n \"def realize(self):\\n if numpy.random.rand() > self._P:\\n self._w *= 0.0\",\n \"def scale_and_translate_points(points):\\n x = points[0]\\n y = points[1]\\n center = points.mean(axis=1) # mean of each row\\n cx = x - center[0] # center the points\\n cy = y - center[1]\\n dist = np.sqrt(np.power(cx, 2) + np.power(cy, 2))\\n scale = np.sqrt(2) / dist.mean()\\n norm3d = np.array([\\n [scale, 0, -scale * center[0]],\\n [0, scale, -scale * center[1]],\\n [0, 0, 1]\\n ])\\n\\n return np.dot(norm3d, points), norm3d\",\n \"def random_point(self, n_samples=1, bound=1.0):\\n samples = self._iterate_over_factors(\\n \\\"random_point\\\", {\\\"n_samples\\\": n_samples, \\\"bound\\\": bound}\\n )\\n return samples\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def scale_model_input(self, sample: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:\\n return sample\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76311445","0.6895509","0.67543155","0.64973104","0.63981426","0.62324494","0.6162519","0.6148883","0.6085778","0.60736156","0.59713405","0.5954016","0.5944525","0.5929756","0.58707345","0.5869925","0.58671856","0.58244807","0.5817822","0.57851666","0.5758104","0.5737039","0.57343966","0.5724114","0.57097816","0.56886965","0.56619024","0.56348586","0.56319606","0.5629389","0.5627564","0.5620456","0.56184846","0.56173605","0.5610144","0.5602059","0.5575629","0.5557948","0.5548345","0.55419457","0.5526402","0.55258346","0.5519874","0.55169934","0.55140567","0.55085343","0.5494804","0.54910403","0.54541165","0.5451928","0.5451928","0.5449282","0.54387385","0.54274344","0.5420843","0.541823","0.5410946","0.54091257","0.53945243","0.5392414","0.53865796","0.5367877","0.5362976","0.5356478","0.53511596","0.53453654","0.5340456","0.53293216","0.5318369","0.53149223","0.53122807","0.5308482","0.53038573","0.52964795","0.5292913","0.52893275","0.5285904","0.5282035","0.5279241","0.52694595","0.52658266","0.52637416","0.52556324","0.5250873","0.52475286","0.5239284","0.5237945","0.5235129","0.52340305","0.5233474","0.5233355","0.52316236","0.52312124","0.5229354","0.52264833","0.52231896","0.5220128","0.5219392","0.5209211","0.5203173"],"string":"[\n \"0.76311445\",\n \"0.6895509\",\n \"0.67543155\",\n \"0.64973104\",\n \"0.63981426\",\n \"0.62324494\",\n \"0.6162519\",\n \"0.6148883\",\n \"0.6085778\",\n \"0.60736156\",\n \"0.59713405\",\n \"0.5954016\",\n \"0.5944525\",\n \"0.5929756\",\n \"0.58707345\",\n \"0.5869925\",\n \"0.58671856\",\n \"0.58244807\",\n \"0.5817822\",\n \"0.57851666\",\n \"0.5758104\",\n \"0.5737039\",\n \"0.57343966\",\n \"0.5724114\",\n \"0.57097816\",\n \"0.56886965\",\n \"0.56619024\",\n \"0.56348586\",\n \"0.56319606\",\n \"0.5629389\",\n \"0.5627564\",\n \"0.5620456\",\n \"0.56184846\",\n \"0.56173605\",\n \"0.5610144\",\n \"0.5602059\",\n \"0.5575629\",\n \"0.5557948\",\n \"0.5548345\",\n \"0.55419457\",\n \"0.5526402\",\n \"0.55258346\",\n \"0.5519874\",\n \"0.55169934\",\n \"0.55140567\",\n \"0.55085343\",\n \"0.5494804\",\n \"0.54910403\",\n \"0.54541165\",\n \"0.5451928\",\n \"0.5451928\",\n \"0.5449282\",\n \"0.54387385\",\n \"0.54274344\",\n \"0.5420843\",\n \"0.541823\",\n \"0.5410946\",\n \"0.54091257\",\n \"0.53945243\",\n \"0.5392414\",\n \"0.53865796\",\n \"0.5367877\",\n \"0.5362976\",\n \"0.5356478\",\n \"0.53511596\",\n \"0.53453654\",\n \"0.5340456\",\n \"0.53293216\",\n \"0.5318369\",\n \"0.53149223\",\n \"0.53122807\",\n \"0.5308482\",\n \"0.53038573\",\n \"0.52964795\",\n \"0.5292913\",\n \"0.52893275\",\n \"0.5285904\",\n \"0.5282035\",\n \"0.5279241\",\n \"0.52694595\",\n \"0.52658266\",\n \"0.52637416\",\n \"0.52556324\",\n \"0.5250873\",\n \"0.52475286\",\n \"0.5239284\",\n \"0.5237945\",\n \"0.5235129\",\n \"0.52340305\",\n \"0.5233474\",\n \"0.5233355\",\n \"0.52316236\",\n \"0.52312124\",\n \"0.5229354\",\n \"0.52264833\",\n \"0.52231896\",\n \"0.5220128\",\n \"0.5219392\",\n \"0.5209211\",\n \"0.5203173\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76930815"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9472,"cells":{"query":{"kind":"string","value":"Shows message on application status bar"},"document":{"kind":"string","value":"def show_status(self, status):\n self.statusBar().showMessage(status, 2000)"},"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 showStatus(self, message):\n self.status_bar.showMessage(message)","def statusbar_msg(self, msg):\n self.statusbar.clearMessage()\n self.statusbar.showMessage(msg)","def display_message(self, message):\n context_id = self.status_bar.get_context_id(\"\")\n self.status_bar.show()\n self.status_bar.push(context_id, message)","def status_display(self, message, level=0, field=0):\n #print(message)\n self.statusbar_txt.set(message)","def setStatus(self, message):\n self.statusBar().showMessage(self.tr(message))","def updateStatusBar(self, statusString):\n self.window().statusBar().showMessage(statusString)","def initStatusBar(self):\n self.statusBar().showMessage(self.tr(\"Ready\"))","def update_status(self, s):\n self.statusbar.showMessage(s)","def updateStatus(self, message):\r\n self.statusBar().showMessage(message, 5000)\r\n if self.kinfilename is not None:\r\n self.setWindowTitle(\"Visualization Tool - %s\" % \\\r\n os.path.basename(unicode(self.kinfilename)))","def set_status(self, string):\n self.statusbar.showMessage(string)\n return","def StatusbarTimer(self):\r\n\t\ttime.sleep(self.statusmsgTimeout)\r\n\t\tself.statusbar.SetStatusText(self.statusmsg)","def showMessage(self, msg):\r\n super(SplashScreen, self).showMessage(\r\n msg, self.labelAlignment, QColor(_QtCore.Qt.white))\r\n QApplication.processEvents()","def updateStatusBar(self):\n text = \"#: %d\" % ( 100 )\n self.statusBar.write(text)","def message(self, msg: str, time=None) -> None:\n bar = self.statusBar()\n if time is None:\n bar.showMessage(msg)\n else:\n bar.showMessage(msg, time)","def printStatusbar(self, data):\r\n\ttry:\r\n \t#wx.CallLater(1800, lambda x: x.SetStatusText(''), self.frame_statusbar)\r\n \tself.frame_statusbar.SetStatusText(data)\r\n\texcept:\r\n\t\tpass","def SetStatusbar(self, msg, timeout=0):\r\n\t\tself.statusmsg = self.statusbar.GetStatusText()\r\n\t\tself.statusbar.SetStatusText(msg, 0)\r\n\t\tself.statusmsgTimeout = timeout\r\n\t\tif timeout != 0:\r\n\t\t\tWT = WorkerThread(self.StatusbarTimer, self)\r\n\t\t\tWT.start()","def __show_app_message(cls, message, level):\n\n ST_MIN_VERSION = 3070\n\n if (int(sublime.version()) >= ST_MIN_VERSION):\n cls.show_popup(message, level)\n else:\n sublime.status_message(message)","def updateStatusBar(self, message):\n #check current status. Precedence is reset > error < warning\n if \"reset\" in message.topic:\n self.sb.SetBackgroundColour((255, 255, 255, 255))\n self.SetStatusText(\"\")\n elif \"warning\" in message.topic:\n self.sb.SetBackgroundColour('yellow')\n self.SetStatusText(\"Warnings generated. Check Log\")\n elif \"error\" in message.topic:\n self.sb.SetBackgroundColour('Red')\n self.SetStatusText(\"Error encountered. Check Log\")\n print message.data\n else:\n self.sb.SetBackgroundColour((255, 255, 255, 255))\n self.SetStatusText(message.data)","def statusBar():\n\tmain_window = MainWindow()\n\treturn main_window.statusBar()","def display_message(self, message, level=\"information\"):\n box = QMessageBox(self.win)\n box.setText(message)\n box.setWindowTitle(QApplication.applicationName())\n if level == \"critical\":\n box.setIcon(QMessageBox.Critical)\n elif level == \"warning\":\n box.setIcon(QMessageBox.Warning)\n else:\n box.setIcon(QMessageBox.Information)\n box.exec_()","def show_statusmessage(self, message='', time=1, clear=False):\n self.parent.show_statusmessage(message, time, clear=clear)","def set_status_text(self, value):\n self.status_bar.SetStatusText(value)","def update_status(self, msg):\n self.status_lbl.config(text=msg)","def _flash(self,id,msg,duration=30.0):\n if duration>0:\n pass #gtk.timeout_add(duration,'')\n return self.statusbar.push(id,msg)","def showMessage(self):","def set_statbar_text(self, msg):\n self.oPB_statBar.showMessage(msg.replace(\"<br>\", \" \").strip(), 0)","def create_status_bar(self):\n self.status_text = QLabel(\"XSpec\")\n self.statusBar().addWidget(self.status_text, 1)","def showMessage(self, msg): \n QtGui.QMessageBox.information(None, \"Info\", msg)","def show_status_message(msg, isok = None):\n mark = u'...'\n if isok is not None:\n mark = u' \\u2714' if isok else u' \\u2718'\n sublime_status_message(u'{0}{1}'.format(msg, mark))","def message(self, message):\n messagebox.showinfo(\n GT_('Menu'),\n message\n )","def _post_message(self, message, timeout=60000):\r\n if self.editor_widget:\r\n statusbar = self.editor_widget.window().statusBar()\r\n statusbar.showMessage(message, timeout)\r\n QApplication.processEvents()","def create_status_bar(self):\n self.statusbar = self.CreateStatusBar()","def show_message(self, message):\n self.sense.show_message(\n message,\n scroll_speed=self.SCROLL_SPEED,\n text_colour=self.TEXT_COLOUR\n )","def update_status(self,txt,wait_time=0,log_type=None):\n try:\n self.ui.statusbar.showMessage(txt,wait_time)\n if log_type is not None:\n self.log_signal.emit(txt)\n logging.info(txt)\n except Exception as e:\n pass","def show_status():\n\n pass","def _setup_status_bar(self):\n self.status = NSStatusBar.systemStatusBar().statusItemWithLength_(NSVariableStatusItemLength)\n self.status.setMenu_(self.status_menu)\n self.status.setTitle_(\"Core\")\n self.status.setHighlightMode_(objc.YES)","def ShowMessage(self, title=u\"\", message=u\"\", msgType=INFOBAR_INFO):\n self.Title.SetLabel(title)\n self.Message.SetLabel(message)\n self.MessageType = msgType\n self.Show(True)","def StatusUpdate(msg):\r\n if verbosity > 0:\r\n print msg","def showMessage(self, message):\r\n print message","def warning_msgbox(self, message, title):\n return os.system(\"zenity --warning --text=\\\"%s\\\" --title=\\\"%s\\\"\" % (message, title))","def StatusUpdate(msg):\n if verbosity > 0:\n print msg","def set_statusbar(self):\n self.statusbar = self.CreateStatusBar()\n self.statusbar.SetFieldsCount(3) # make 3 of them\n self.statusbar.SetStatusWidths([-1,-1,-2]) # last one is 2x size of 1st and 2nd, all stretch as needed\n self.statusbar.SetStatusText(\"\", 0)\n self.statusbar.SetStatusText(\"Namelist:\", 1)\n self.statusbar.SetStatusText(\"File:\", 2)","def show_messages(self):\n console.alert(\n \"Info\",\n \"If StaSh does not launch anymore after you changed the config, run the 'launch_stash.py' script with \\n'--no-cfgfile'.\",\n \"Ok\",\n hide_cancel_button=True,\n )\n while True:\n self.wait_modal()\n if not self.subview_open:\n break\n console.alert(\n \"Info\",\n \"Some changes may only be visible after restarting StaSh and/or Pythonista.\",\n \"Ok\",\n hide_cancel_button=True,\n )","def msg_window(text):\n msg = QMessageBox()\n msg.setIcon(QMessageBox.Information)\n msg.setText(text)\n msg.setWindowTitle(\"Info\")\n msg.exec_()","def windowsMessageBox(message, title=\"Natlink configure program\"):\n MessageBox(message, title)","def SetStatusMessage(self, msg):\n if self._status_msg_fn:\n self._status_msg_fn(msg)\n else:\n tf.logging.info('Status: %s', msg)","def sublime_status_message(msg):\n sublime.set_timeout(lambda: sublime.status_message(u'SublimeHaskell: {0}'.format(msg)), 0)","def show_message(self, title: str, message: str):\n QMessageBox.about(self, title, message)","def showwarning(parent, message, title, flags = wx.OK | wx.ICON_WARNING): \n\tshowmessage(parent, message, title, flags)","def reset_statusbar(self, text=\"\", ind=0):\n self.statusbar.SetStatusText(text, ind)","def display(self):\n self.tabbar.refresh()\n self.noact_pane.display()\n self.act_pane.display()\n self.statusbar.set_strings(self.act_pane.act_tab.build_status_line())\n self.statusbar.refresh()","def _update_status(self, message):\n message = \"[{}] {}\".format(strftime(\"%H:%M:%S\", localtime()), message)\n self.tracker.write_log(message)\n self.ui.update_status(message)","def updateStatus(self, msg, left=True):\n if self.gui is not None:\n if left:\n self.gui.setStatusL(msg) # fails if no gui\n else:\n self.gui.setStatusR(msg)\n else:\n # no gui - print to terminal\n # print(msg)\n logging.info(\"STATUS (no GUI): {}\".format(msg))","def showinfo(self, msg):\n tkinter.messagebox.showinfo('Information', msg)","def OnUpdateActive(self, event):\n self.StatusbarUpdate()","def about(self):\n self.main_window.message(\n width=200, aspect=100, justify=tkinter.CENTER,\n text=\"Jeu de Ping\\n\\n\"\n \"(C) Maximin Duvillard, August 2022.\\nLicence = GPL\")","def showMessage(self, message):\r\n util.raiseNotDefined()","def show_bottom_status(self):\n editor = self.app.get_editor()\n size = self.size()\n cur = editor.cursor()\n data = \"@ \"+str(cur[0])+\",\"+str(cur[1])+\" \"+\\\n \"cur:\"+str(len(editor.cursors))+\" \"+\\\n \"buf:\"+str(len(editor.buffer))\n if self.app.config[\"display\"][\"show_last_key\"]:\n data += \" key:\"+str(self.app.last_input)\n #if self.app.config[\"display\"][\"show_term_size\"]:\n # data += \" [\"+str(size[0])+\"x\"+str(size[1])+\"]\"\n if self.app.config[\"app\"][\"debug\"]:\n data += \" cs:\"+str(editor.current_state)+\" hist:\"+str(len(editor.history)) # Undo / Redo debug\n #if editor.last_find:\n # find = editor.last_find\n # if len(find) > 10:find = find[:10]+\"...\"\n # data = \"find:'\"+find+\"' \" + data\n\n # Add module statuses to the status bar\n for name in self.app.modules.modules.keys():\n module = self.app.modules.modules[name]\n if module.options[\"status\"] == \"bottom\":\n data += \" \" + module.get_status();\n\n self.status_win.clear()\n status = self.app.get_status()\n extra = size[0] - len(status+data) - 1\n line = status+(\" \"*extra)+data\n\n if len(line) >= size[0]:\n line = line[:size[0]-1]\n\n self.status_win.addstr(0,0, line, curses.color_pair(0) | curses.A_REVERSE)\n self.status_win.refresh()","def status(s):\n print('\\033[1m{0}\\033[0m'.format(s))\n time.sleep(2)","def show_top_status(self):\n self.header_win.clear()\n size = self.size()\n display = self.app.config[\"display\"]\n head_parts = []\n if display[\"show_app_name\"]:\n head_parts.append(\"Suplemon Editor v\"+self.app.version)\n if display[\"show_clock\"]:\n head_parts.append(curr_time())\n if display[\"show_file_list\"]:\n head_parts.append(self.file_list_str())\n\n # Add module statuses to the status bar\n for name in self.app.modules.modules.keys():\n module = self.app.modules.modules[name]\n if module.options[\"status\"] == \"top\":\n head_parts.append(module.get_status());\n\n head = \" - \".join(head_parts)\n head = head + ( \" \" * (self.screen.getmaxyx()[1]-len(head)-1) )\n if len(head) >= size[0]:\n head = head[:size[0]-1]\n self.header_win.addstr(0,0, head, curses.color_pair(0) | curses.A_REVERSE)\n self.header_win.refresh()","def display_message():","def status_msg(self, msg):\n\n\t\tprint(\"function not supported yet\")","def setStatus(self,text:str) -> None:\n self.logger.info(text)\n self.appendReport(text)\n self.status.config(text=text)\n self.root.update_idletasks()","def disp_msg(msg):\n from x84.bbs import getterminal, echo\n term = getterminal()\n echo(u''.join((u'\\r\\n\\r\\n',\n term.bold_yellow('%s ' % (msg,),),\n term.yellow_reverse_bold(u'...'),)))","def draw_status_bar(self, screen: curses.window) -> None:\n sh, sw = screen.getmaxyx()\n cpu_percent = psutil.cpu_percent()\n status_bar_text = f\"Press 'q' to exit | STATUS BAR | CPU Usage: {cpu_percent}%\"\n whitespace_width = \" \" * (sw - len(status_bar_text) - 1)\n add_str_color(screen, sh - 1, 0, status_bar_text, ColorPair.black_on_white)\n add_str_color(screen, sh - 1, len(status_bar_text), whitespace_width, ColorPair.black_on_white)\n\n # Add space in corner using insch so it doesn't wrap and cause an error\n ins_ch_color(screen, sh - 1, sw - 1, ' ', ColorPair.black_on_white)","def _drawstatus(self):\n (y, x) = self.chatscreen.getmaxyx()\n\n fillchar = '*' if self.busy > 0 else '-'\n form = '{:'+ fillchar +'^' + str(x - 1) + '}'\n\n self.chatscreen.addstr(y-1, 0, form.format('%s' % self.status()))","def status(self, msg):\n oscid = self.app.global_osc_id()\n print(\"STATUS : /Llia/%s : %s\" % (oscid, msg))","def informationMessage(self,message):\n msgBox = QMessageBox()\n msgBox.setIcon(QMessageBox.Warning)\n msgBox.setWindowTitle(\"Information\")\n msgBox.setText(message)\n msgBox.exec()","def log_text(self, screens_to_update, text):\n if type(self._frame) in screens_to_update:\n self._frame.status_text_component.status.configure(text=text)","def notifyUser(self, message):\n\n\n msg = QtWidgets.QMessageBox(self)\n msg.setText(message)\n msg.exec_()","def updateStatus(self, newStatus = False):\n\t\theight, width = self.screen.getmaxyx()\n\t\tif newStatus:\n\t\t\tself.status = str(newStatus)\n\t\tspaces = width - len(self.status) - 2\n\t\tself.wts(height - 1, 1, self.status + ' ' * spaces , 1)\n\t\tself.screen.refresh()","def msg_show(self,msg):\r\n self.frame.Show()\r\n self.frame.Raise()","def display_message_on_ableton(self, message):\n self._show_message(message)","def display_message(window, msg):\n v = create_output_panel(window, '')\n _append(v, msg)","def windowsMessageBox(message, title=\"Natlink configure program\"):\n MessageBoxA(None, message, title, 0)","def display_status_box(self):\n \n text = self.font_small.render(\"Level: \" + str(self.current_level), True,\n self.display_states[self.display_names[self.current_display_state]]['text'],\n self.display_states[self.display_names[self.current_display_state]]['background'])\n temp_width = text.get_rect().width\n self.gameDisplay.blit(text, ((self.SCREEN_WIDTH / 10) - (temp_width/2), 10))","def show_notification(self, message: str, also_cmd: bool = False):\n if platform_string == \"Linux\":\n try:\n notification = notify2.Notification('LTU Assistant',\n message,\n 'notification-message-im')\n notification.show()\n except dbus.exceptions.DBusException:\n if not also_cmd:\n print(message)\n elif platform_string == \"Windows\":\n toaster.show_toast(\"LTU Assistant\", message, threaded=True)","async def show_notification(self, message: str, timeout: int):\n self.notification_text = HTML(\n f'<style bg=\"white\" color=\"black\">[ {message} ]</style>'\n )\n await asyncio.sleep(timeout)\n self.notification_text = None","def _createStatusBar(self) -> None:\n self._statusBar = QStatusBar()\n self.setStatusBar(self._statusBar)","def on_launch():\n return get_welcome_message()","def __output(self,msg,status):\n status = int(status)\n if status:\n print \"%s-----------\\033[1;37;42m%s\\033[0m\" % (format(msg,\"<15\"),\"OK\")\n else:\n print \"%s***********\\033[1;37;41m%s\\033[0m\" % (format(msg,\"<15\"),\"ERROR\")","def showMessage(self, msg):\n msgBox = QMessageBox()\n msgBox.setText(msg)\n #msgBox.setInformativeText(\"Do you want to save your changes?\")\n #msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);\n #msgBox.setDefaultButton(QMessageBox::Save);\n ret = msgBox.exec();","def _onAbout(self, event):\n wx.MessageBox(\"This is a wxPython Hello World sample\",\n \"About Hello World 2\",\n wx.OK | wx.ICON_INFORMATION)","def UpdatePipelineToolStatusLabel( gui, statusMessage ):\n gui.pipelineToolStatusLabel.setText( statusMessage )","def display_message(self, message):\n\t\tself.render('message.html', {'message': message})","def activate_statusbar_icon_close():\n pass","def status(s):\n print(\"\\033[1m{0}\\033[0m\".format(s))","def status(s):\n print(\"\\033[1m{0}\\033[0m\".format(s))","def status(s):\n print(\"\\033[1m{0}\\033[0m\".format(s))","def status(s):\n print(\"\\033[1m{0}\\033[0m\".format(s))","def show_warning(title, message, print_message=False):\n\n pass","def show_menu(self, update, context):\n msg_file = 'menu_msg.txt'\n self.send_textfile(msg_file, update, context)","def activate_statusbar_icon_mode():\n pass","def status(s):\n print('\\033[1m{0}\\033[0m'.format(s))","def status(s):\n print('\\033[1m{0}\\033[0m'.format(s))","def status(s):\n print('\\033[1m{0}\\033[0m'.format(s))","def status(s):\n print('\\033[1m{0}\\033[0m'.format(s))","def status(s: str):\n print(\"\\033[1m{0}\\033[0m\".format(s))","async def update_status_message(self):\n embed, components = self.get_status_embed_and_components()\n await self.client.message_edit(self.status_message, embed = embed, components = components)","def _display_message(message: str) -> None:\n print(message)"],"string":"[\n \"def showStatus(self, message):\\n self.status_bar.showMessage(message)\",\n \"def statusbar_msg(self, msg):\\n self.statusbar.clearMessage()\\n self.statusbar.showMessage(msg)\",\n \"def display_message(self, message):\\n context_id = self.status_bar.get_context_id(\\\"\\\")\\n self.status_bar.show()\\n self.status_bar.push(context_id, message)\",\n \"def status_display(self, message, level=0, field=0):\\n #print(message)\\n self.statusbar_txt.set(message)\",\n \"def setStatus(self, message):\\n self.statusBar().showMessage(self.tr(message))\",\n \"def updateStatusBar(self, statusString):\\n self.window().statusBar().showMessage(statusString)\",\n \"def initStatusBar(self):\\n self.statusBar().showMessage(self.tr(\\\"Ready\\\"))\",\n \"def update_status(self, s):\\n self.statusbar.showMessage(s)\",\n \"def updateStatus(self, message):\\r\\n self.statusBar().showMessage(message, 5000)\\r\\n if self.kinfilename is not None:\\r\\n self.setWindowTitle(\\\"Visualization Tool - %s\\\" % \\\\\\r\\n os.path.basename(unicode(self.kinfilename)))\",\n \"def set_status(self, string):\\n self.statusbar.showMessage(string)\\n return\",\n \"def StatusbarTimer(self):\\r\\n\\t\\ttime.sleep(self.statusmsgTimeout)\\r\\n\\t\\tself.statusbar.SetStatusText(self.statusmsg)\",\n \"def showMessage(self, msg):\\r\\n super(SplashScreen, self).showMessage(\\r\\n msg, self.labelAlignment, QColor(_QtCore.Qt.white))\\r\\n QApplication.processEvents()\",\n \"def updateStatusBar(self):\\n text = \\\"#: %d\\\" % ( 100 )\\n self.statusBar.write(text)\",\n \"def message(self, msg: str, time=None) -> None:\\n bar = self.statusBar()\\n if time is None:\\n bar.showMessage(msg)\\n else:\\n bar.showMessage(msg, time)\",\n \"def printStatusbar(self, data):\\r\\n\\ttry:\\r\\n \\t#wx.CallLater(1800, lambda x: x.SetStatusText(''), self.frame_statusbar)\\r\\n \\tself.frame_statusbar.SetStatusText(data)\\r\\n\\texcept:\\r\\n\\t\\tpass\",\n \"def SetStatusbar(self, msg, timeout=0):\\r\\n\\t\\tself.statusmsg = self.statusbar.GetStatusText()\\r\\n\\t\\tself.statusbar.SetStatusText(msg, 0)\\r\\n\\t\\tself.statusmsgTimeout = timeout\\r\\n\\t\\tif timeout != 0:\\r\\n\\t\\t\\tWT = WorkerThread(self.StatusbarTimer, self)\\r\\n\\t\\t\\tWT.start()\",\n \"def __show_app_message(cls, message, level):\\n\\n ST_MIN_VERSION = 3070\\n\\n if (int(sublime.version()) >= ST_MIN_VERSION):\\n cls.show_popup(message, level)\\n else:\\n sublime.status_message(message)\",\n \"def updateStatusBar(self, message):\\n #check current status. Precedence is reset > error < warning\\n if \\\"reset\\\" in message.topic:\\n self.sb.SetBackgroundColour((255, 255, 255, 255))\\n self.SetStatusText(\\\"\\\")\\n elif \\\"warning\\\" in message.topic:\\n self.sb.SetBackgroundColour('yellow')\\n self.SetStatusText(\\\"Warnings generated. Check Log\\\")\\n elif \\\"error\\\" in message.topic:\\n self.sb.SetBackgroundColour('Red')\\n self.SetStatusText(\\\"Error encountered. Check Log\\\")\\n print message.data\\n else:\\n self.sb.SetBackgroundColour((255, 255, 255, 255))\\n self.SetStatusText(message.data)\",\n \"def statusBar():\\n\\tmain_window = MainWindow()\\n\\treturn main_window.statusBar()\",\n \"def display_message(self, message, level=\\\"information\\\"):\\n box = QMessageBox(self.win)\\n box.setText(message)\\n box.setWindowTitle(QApplication.applicationName())\\n if level == \\\"critical\\\":\\n box.setIcon(QMessageBox.Critical)\\n elif level == \\\"warning\\\":\\n box.setIcon(QMessageBox.Warning)\\n else:\\n box.setIcon(QMessageBox.Information)\\n box.exec_()\",\n \"def show_statusmessage(self, message='', time=1, clear=False):\\n self.parent.show_statusmessage(message, time, clear=clear)\",\n \"def set_status_text(self, value):\\n self.status_bar.SetStatusText(value)\",\n \"def update_status(self, msg):\\n self.status_lbl.config(text=msg)\",\n \"def _flash(self,id,msg,duration=30.0):\\n if duration>0:\\n pass #gtk.timeout_add(duration,'')\\n return self.statusbar.push(id,msg)\",\n \"def showMessage(self):\",\n \"def set_statbar_text(self, msg):\\n self.oPB_statBar.showMessage(msg.replace(\\\"<br>\\\", \\\" \\\").strip(), 0)\",\n \"def create_status_bar(self):\\n self.status_text = QLabel(\\\"XSpec\\\")\\n self.statusBar().addWidget(self.status_text, 1)\",\n \"def showMessage(self, msg): \\n QtGui.QMessageBox.information(None, \\\"Info\\\", msg)\",\n \"def show_status_message(msg, isok = None):\\n mark = u'...'\\n if isok is not None:\\n mark = u' \\\\u2714' if isok else u' \\\\u2718'\\n sublime_status_message(u'{0}{1}'.format(msg, mark))\",\n \"def message(self, message):\\n messagebox.showinfo(\\n GT_('Menu'),\\n message\\n )\",\n \"def _post_message(self, message, timeout=60000):\\r\\n if self.editor_widget:\\r\\n statusbar = self.editor_widget.window().statusBar()\\r\\n statusbar.showMessage(message, timeout)\\r\\n QApplication.processEvents()\",\n \"def create_status_bar(self):\\n self.statusbar = self.CreateStatusBar()\",\n \"def show_message(self, message):\\n self.sense.show_message(\\n message,\\n scroll_speed=self.SCROLL_SPEED,\\n text_colour=self.TEXT_COLOUR\\n )\",\n \"def update_status(self,txt,wait_time=0,log_type=None):\\n try:\\n self.ui.statusbar.showMessage(txt,wait_time)\\n if log_type is not None:\\n self.log_signal.emit(txt)\\n logging.info(txt)\\n except Exception as e:\\n pass\",\n \"def show_status():\\n\\n pass\",\n \"def _setup_status_bar(self):\\n self.status = NSStatusBar.systemStatusBar().statusItemWithLength_(NSVariableStatusItemLength)\\n self.status.setMenu_(self.status_menu)\\n self.status.setTitle_(\\\"Core\\\")\\n self.status.setHighlightMode_(objc.YES)\",\n \"def ShowMessage(self, title=u\\\"\\\", message=u\\\"\\\", msgType=INFOBAR_INFO):\\n self.Title.SetLabel(title)\\n self.Message.SetLabel(message)\\n self.MessageType = msgType\\n self.Show(True)\",\n \"def StatusUpdate(msg):\\r\\n if verbosity > 0:\\r\\n print msg\",\n \"def showMessage(self, message):\\r\\n print message\",\n \"def warning_msgbox(self, message, title):\\n return os.system(\\\"zenity --warning --text=\\\\\\\"%s\\\\\\\" --title=\\\\\\\"%s\\\\\\\"\\\" % (message, title))\",\n \"def StatusUpdate(msg):\\n if verbosity > 0:\\n print msg\",\n \"def set_statusbar(self):\\n self.statusbar = self.CreateStatusBar()\\n self.statusbar.SetFieldsCount(3) # make 3 of them\\n self.statusbar.SetStatusWidths([-1,-1,-2]) # last one is 2x size of 1st and 2nd, all stretch as needed\\n self.statusbar.SetStatusText(\\\"\\\", 0)\\n self.statusbar.SetStatusText(\\\"Namelist:\\\", 1)\\n self.statusbar.SetStatusText(\\\"File:\\\", 2)\",\n \"def show_messages(self):\\n console.alert(\\n \\\"Info\\\",\\n \\\"If StaSh does not launch anymore after you changed the config, run the 'launch_stash.py' script with \\\\n'--no-cfgfile'.\\\",\\n \\\"Ok\\\",\\n hide_cancel_button=True,\\n )\\n while True:\\n self.wait_modal()\\n if not self.subview_open:\\n break\\n console.alert(\\n \\\"Info\\\",\\n \\\"Some changes may only be visible after restarting StaSh and/or Pythonista.\\\",\\n \\\"Ok\\\",\\n hide_cancel_button=True,\\n )\",\n \"def msg_window(text):\\n msg = QMessageBox()\\n msg.setIcon(QMessageBox.Information)\\n msg.setText(text)\\n msg.setWindowTitle(\\\"Info\\\")\\n msg.exec_()\",\n \"def windowsMessageBox(message, title=\\\"Natlink configure program\\\"):\\n MessageBox(message, title)\",\n \"def SetStatusMessage(self, msg):\\n if self._status_msg_fn:\\n self._status_msg_fn(msg)\\n else:\\n tf.logging.info('Status: %s', msg)\",\n \"def sublime_status_message(msg):\\n sublime.set_timeout(lambda: sublime.status_message(u'SublimeHaskell: {0}'.format(msg)), 0)\",\n \"def show_message(self, title: str, message: str):\\n QMessageBox.about(self, title, message)\",\n \"def showwarning(parent, message, title, flags = wx.OK | wx.ICON_WARNING): \\n\\tshowmessage(parent, message, title, flags)\",\n \"def reset_statusbar(self, text=\\\"\\\", ind=0):\\n self.statusbar.SetStatusText(text, ind)\",\n \"def display(self):\\n self.tabbar.refresh()\\n self.noact_pane.display()\\n self.act_pane.display()\\n self.statusbar.set_strings(self.act_pane.act_tab.build_status_line())\\n self.statusbar.refresh()\",\n \"def _update_status(self, message):\\n message = \\\"[{}] {}\\\".format(strftime(\\\"%H:%M:%S\\\", localtime()), message)\\n self.tracker.write_log(message)\\n self.ui.update_status(message)\",\n \"def updateStatus(self, msg, left=True):\\n if self.gui is not None:\\n if left:\\n self.gui.setStatusL(msg) # fails if no gui\\n else:\\n self.gui.setStatusR(msg)\\n else:\\n # no gui - print to terminal\\n # print(msg)\\n logging.info(\\\"STATUS (no GUI): {}\\\".format(msg))\",\n \"def showinfo(self, msg):\\n tkinter.messagebox.showinfo('Information', msg)\",\n \"def OnUpdateActive(self, event):\\n self.StatusbarUpdate()\",\n \"def about(self):\\n self.main_window.message(\\n width=200, aspect=100, justify=tkinter.CENTER,\\n text=\\\"Jeu de Ping\\\\n\\\\n\\\"\\n \\\"(C) Maximin Duvillard, August 2022.\\\\nLicence = GPL\\\")\",\n \"def showMessage(self, message):\\r\\n util.raiseNotDefined()\",\n \"def show_bottom_status(self):\\n editor = self.app.get_editor()\\n size = self.size()\\n cur = editor.cursor()\\n data = \\\"@ \\\"+str(cur[0])+\\\",\\\"+str(cur[1])+\\\" \\\"+\\\\\\n \\\"cur:\\\"+str(len(editor.cursors))+\\\" \\\"+\\\\\\n \\\"buf:\\\"+str(len(editor.buffer))\\n if self.app.config[\\\"display\\\"][\\\"show_last_key\\\"]:\\n data += \\\" key:\\\"+str(self.app.last_input)\\n #if self.app.config[\\\"display\\\"][\\\"show_term_size\\\"]:\\n # data += \\\" [\\\"+str(size[0])+\\\"x\\\"+str(size[1])+\\\"]\\\"\\n if self.app.config[\\\"app\\\"][\\\"debug\\\"]:\\n data += \\\" cs:\\\"+str(editor.current_state)+\\\" hist:\\\"+str(len(editor.history)) # Undo / Redo debug\\n #if editor.last_find:\\n # find = editor.last_find\\n # if len(find) > 10:find = find[:10]+\\\"...\\\"\\n # data = \\\"find:'\\\"+find+\\\"' \\\" + data\\n\\n # Add module statuses to the status bar\\n for name in self.app.modules.modules.keys():\\n module = self.app.modules.modules[name]\\n if module.options[\\\"status\\\"] == \\\"bottom\\\":\\n data += \\\" \\\" + module.get_status();\\n\\n self.status_win.clear()\\n status = self.app.get_status()\\n extra = size[0] - len(status+data) - 1\\n line = status+(\\\" \\\"*extra)+data\\n\\n if len(line) >= size[0]:\\n line = line[:size[0]-1]\\n\\n self.status_win.addstr(0,0, line, curses.color_pair(0) | curses.A_REVERSE)\\n self.status_win.refresh()\",\n \"def status(s):\\n print('\\\\033[1m{0}\\\\033[0m'.format(s))\\n time.sleep(2)\",\n \"def show_top_status(self):\\n self.header_win.clear()\\n size = self.size()\\n display = self.app.config[\\\"display\\\"]\\n head_parts = []\\n if display[\\\"show_app_name\\\"]:\\n head_parts.append(\\\"Suplemon Editor v\\\"+self.app.version)\\n if display[\\\"show_clock\\\"]:\\n head_parts.append(curr_time())\\n if display[\\\"show_file_list\\\"]:\\n head_parts.append(self.file_list_str())\\n\\n # Add module statuses to the status bar\\n for name in self.app.modules.modules.keys():\\n module = self.app.modules.modules[name]\\n if module.options[\\\"status\\\"] == \\\"top\\\":\\n head_parts.append(module.get_status());\\n\\n head = \\\" - \\\".join(head_parts)\\n head = head + ( \\\" \\\" * (self.screen.getmaxyx()[1]-len(head)-1) )\\n if len(head) >= size[0]:\\n head = head[:size[0]-1]\\n self.header_win.addstr(0,0, head, curses.color_pair(0) | curses.A_REVERSE)\\n self.header_win.refresh()\",\n \"def display_message():\",\n \"def status_msg(self, msg):\\n\\n\\t\\tprint(\\\"function not supported yet\\\")\",\n \"def setStatus(self,text:str) -> None:\\n self.logger.info(text)\\n self.appendReport(text)\\n self.status.config(text=text)\\n self.root.update_idletasks()\",\n \"def disp_msg(msg):\\n from x84.bbs import getterminal, echo\\n term = getterminal()\\n echo(u''.join((u'\\\\r\\\\n\\\\r\\\\n',\\n term.bold_yellow('%s ' % (msg,),),\\n term.yellow_reverse_bold(u'...'),)))\",\n \"def draw_status_bar(self, screen: curses.window) -> None:\\n sh, sw = screen.getmaxyx()\\n cpu_percent = psutil.cpu_percent()\\n status_bar_text = f\\\"Press 'q' to exit | STATUS BAR | CPU Usage: {cpu_percent}%\\\"\\n whitespace_width = \\\" \\\" * (sw - len(status_bar_text) - 1)\\n add_str_color(screen, sh - 1, 0, status_bar_text, ColorPair.black_on_white)\\n add_str_color(screen, sh - 1, len(status_bar_text), whitespace_width, ColorPair.black_on_white)\\n\\n # Add space in corner using insch so it doesn't wrap and cause an error\\n ins_ch_color(screen, sh - 1, sw - 1, ' ', ColorPair.black_on_white)\",\n \"def _drawstatus(self):\\n (y, x) = self.chatscreen.getmaxyx()\\n\\n fillchar = '*' if self.busy > 0 else '-'\\n form = '{:'+ fillchar +'^' + str(x - 1) + '}'\\n\\n self.chatscreen.addstr(y-1, 0, form.format('%s' % self.status()))\",\n \"def status(self, msg):\\n oscid = self.app.global_osc_id()\\n print(\\\"STATUS : /Llia/%s : %s\\\" % (oscid, msg))\",\n \"def informationMessage(self,message):\\n msgBox = QMessageBox()\\n msgBox.setIcon(QMessageBox.Warning)\\n msgBox.setWindowTitle(\\\"Information\\\")\\n msgBox.setText(message)\\n msgBox.exec()\",\n \"def log_text(self, screens_to_update, text):\\n if type(self._frame) in screens_to_update:\\n self._frame.status_text_component.status.configure(text=text)\",\n \"def notifyUser(self, message):\\n\\n\\n msg = QtWidgets.QMessageBox(self)\\n msg.setText(message)\\n msg.exec_()\",\n \"def updateStatus(self, newStatus = False):\\n\\t\\theight, width = self.screen.getmaxyx()\\n\\t\\tif newStatus:\\n\\t\\t\\tself.status = str(newStatus)\\n\\t\\tspaces = width - len(self.status) - 2\\n\\t\\tself.wts(height - 1, 1, self.status + ' ' * spaces , 1)\\n\\t\\tself.screen.refresh()\",\n \"def msg_show(self,msg):\\r\\n self.frame.Show()\\r\\n self.frame.Raise()\",\n \"def display_message_on_ableton(self, message):\\n self._show_message(message)\",\n \"def display_message(window, msg):\\n v = create_output_panel(window, '')\\n _append(v, msg)\",\n \"def windowsMessageBox(message, title=\\\"Natlink configure program\\\"):\\n MessageBoxA(None, message, title, 0)\",\n \"def display_status_box(self):\\n \\n text = self.font_small.render(\\\"Level: \\\" + str(self.current_level), True,\\n self.display_states[self.display_names[self.current_display_state]]['text'],\\n self.display_states[self.display_names[self.current_display_state]]['background'])\\n temp_width = text.get_rect().width\\n self.gameDisplay.blit(text, ((self.SCREEN_WIDTH / 10) - (temp_width/2), 10))\",\n \"def show_notification(self, message: str, also_cmd: bool = False):\\n if platform_string == \\\"Linux\\\":\\n try:\\n notification = notify2.Notification('LTU Assistant',\\n message,\\n 'notification-message-im')\\n notification.show()\\n except dbus.exceptions.DBusException:\\n if not also_cmd:\\n print(message)\\n elif platform_string == \\\"Windows\\\":\\n toaster.show_toast(\\\"LTU Assistant\\\", message, threaded=True)\",\n \"async def show_notification(self, message: str, timeout: int):\\n self.notification_text = HTML(\\n f'<style bg=\\\"white\\\" color=\\\"black\\\">[ {message} ]</style>'\\n )\\n await asyncio.sleep(timeout)\\n self.notification_text = None\",\n \"def _createStatusBar(self) -> None:\\n self._statusBar = QStatusBar()\\n self.setStatusBar(self._statusBar)\",\n \"def on_launch():\\n return get_welcome_message()\",\n \"def __output(self,msg,status):\\n status = int(status)\\n if status:\\n print \\\"%s-----------\\\\033[1;37;42m%s\\\\033[0m\\\" % (format(msg,\\\"<15\\\"),\\\"OK\\\")\\n else:\\n print \\\"%s***********\\\\033[1;37;41m%s\\\\033[0m\\\" % (format(msg,\\\"<15\\\"),\\\"ERROR\\\")\",\n \"def showMessage(self, msg):\\n msgBox = QMessageBox()\\n msgBox.setText(msg)\\n #msgBox.setInformativeText(\\\"Do you want to save your changes?\\\")\\n #msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);\\n #msgBox.setDefaultButton(QMessageBox::Save);\\n ret = msgBox.exec();\",\n \"def _onAbout(self, event):\\n wx.MessageBox(\\\"This is a wxPython Hello World sample\\\",\\n \\\"About Hello World 2\\\",\\n wx.OK | wx.ICON_INFORMATION)\",\n \"def UpdatePipelineToolStatusLabel( gui, statusMessage ):\\n gui.pipelineToolStatusLabel.setText( statusMessage )\",\n \"def display_message(self, message):\\n\\t\\tself.render('message.html', {'message': message})\",\n \"def activate_statusbar_icon_close():\\n pass\",\n \"def status(s):\\n print(\\\"\\\\033[1m{0}\\\\033[0m\\\".format(s))\",\n \"def status(s):\\n print(\\\"\\\\033[1m{0}\\\\033[0m\\\".format(s))\",\n \"def status(s):\\n print(\\\"\\\\033[1m{0}\\\\033[0m\\\".format(s))\",\n \"def status(s):\\n print(\\\"\\\\033[1m{0}\\\\033[0m\\\".format(s))\",\n \"def show_warning(title, message, print_message=False):\\n\\n pass\",\n \"def show_menu(self, update, context):\\n msg_file = 'menu_msg.txt'\\n self.send_textfile(msg_file, update, context)\",\n \"def activate_statusbar_icon_mode():\\n pass\",\n \"def status(s):\\n print('\\\\033[1m{0}\\\\033[0m'.format(s))\",\n \"def status(s):\\n print('\\\\033[1m{0}\\\\033[0m'.format(s))\",\n \"def status(s):\\n print('\\\\033[1m{0}\\\\033[0m'.format(s))\",\n \"def status(s):\\n print('\\\\033[1m{0}\\\\033[0m'.format(s))\",\n \"def status(s: str):\\n print(\\\"\\\\033[1m{0}\\\\033[0m\\\".format(s))\",\n \"async def update_status_message(self):\\n embed, components = self.get_status_embed_and_components()\\n await self.client.message_edit(self.status_message, embed = embed, components = components)\",\n \"def _display_message(message: str) -> None:\\n print(message)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84011865","0.833993","0.8174036","0.77206886","0.76677835","0.75396955","0.75219834","0.75037515","0.7410699","0.73903996","0.7333679","0.72647804","0.7226942","0.70724267","0.7072069","0.7037532","0.70224166","0.69146335","0.6912863","0.6885066","0.6815968","0.6725531","0.67064875","0.6654734","0.6612853","0.6593732","0.658469","0.6565518","0.64771724","0.64563787","0.64457375","0.6418359","0.63896424","0.63891846","0.63756996","0.6362137","0.6356621","0.6326107","0.631953","0.630669","0.626812","0.62267995","0.6222581","0.62015736","0.6200064","0.6199865","0.61914045","0.61852825","0.6182319","0.61582536","0.6157704","0.6152377","0.6136255","0.6132629","0.61213297","0.61127645","0.60962445","0.6086075","0.6083577","0.6083539","0.60761905","0.6074981","0.6071631","0.6053237","0.604271","0.60258347","0.6023062","0.60215193","0.6006243","0.59954685","0.5981392","0.5977496","0.5972202","0.59679896","0.59602726","0.5949503","0.5947146","0.59437406","0.5933482","0.59188133","0.5918614","0.5916482","0.5915101","0.59018797","0.5865814","0.58562785","0.5853327","0.5853327","0.5853327","0.5853327","0.5847871","0.5846743","0.58411413","0.5838405","0.5838405","0.5838405","0.5838405","0.5836059","0.5828673","0.58206236"],"string":"[\n \"0.84011865\",\n \"0.833993\",\n \"0.8174036\",\n \"0.77206886\",\n \"0.76677835\",\n \"0.75396955\",\n \"0.75219834\",\n \"0.75037515\",\n \"0.7410699\",\n \"0.73903996\",\n \"0.7333679\",\n \"0.72647804\",\n \"0.7226942\",\n \"0.70724267\",\n \"0.7072069\",\n \"0.7037532\",\n \"0.70224166\",\n \"0.69146335\",\n \"0.6912863\",\n \"0.6885066\",\n \"0.6815968\",\n \"0.6725531\",\n \"0.67064875\",\n \"0.6654734\",\n \"0.6612853\",\n \"0.6593732\",\n \"0.658469\",\n \"0.6565518\",\n \"0.64771724\",\n \"0.64563787\",\n \"0.64457375\",\n \"0.6418359\",\n \"0.63896424\",\n \"0.63891846\",\n \"0.63756996\",\n \"0.6362137\",\n \"0.6356621\",\n \"0.6326107\",\n \"0.631953\",\n \"0.630669\",\n \"0.626812\",\n \"0.62267995\",\n \"0.6222581\",\n \"0.62015736\",\n \"0.6200064\",\n \"0.6199865\",\n \"0.61914045\",\n \"0.61852825\",\n \"0.6182319\",\n \"0.61582536\",\n \"0.6157704\",\n \"0.6152377\",\n \"0.6136255\",\n \"0.6132629\",\n \"0.61213297\",\n \"0.61127645\",\n \"0.60962445\",\n \"0.6086075\",\n \"0.6083577\",\n \"0.6083539\",\n \"0.60761905\",\n \"0.6074981\",\n \"0.6071631\",\n \"0.6053237\",\n \"0.604271\",\n \"0.60258347\",\n \"0.6023062\",\n \"0.60215193\",\n \"0.6006243\",\n \"0.59954685\",\n \"0.5981392\",\n \"0.5977496\",\n \"0.5972202\",\n \"0.59679896\",\n \"0.59602726\",\n \"0.5949503\",\n \"0.5947146\",\n \"0.59437406\",\n \"0.5933482\",\n \"0.59188133\",\n \"0.5918614\",\n \"0.5916482\",\n \"0.5915101\",\n \"0.59018797\",\n \"0.5865814\",\n \"0.58562785\",\n \"0.5853327\",\n \"0.5853327\",\n \"0.5853327\",\n \"0.5853327\",\n \"0.5847871\",\n \"0.5846743\",\n \"0.58411413\",\n \"0.5838405\",\n \"0.5838405\",\n \"0.5838405\",\n \"0.5838405\",\n \"0.5836059\",\n \"0.5828673\",\n \"0.58206236\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81817955"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":9473,"cells":{"query":{"kind":"string","value":"Override the closeEvent method"},"document":{"kind":"string","value":"def closeEvent(self, event):\n if settings.IN_SYNC:\n event.ignore()\n QtGui.QMessageBox.information(self, \"Abort\", \"You are in the middle of \"\n + \"a conflicted merge. Please resolve it first.\")\n else:\n event.accept()"},"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 outCloseEvent(self):\r\n pass","def onClose(self, event):\n pass","def onClose(self, event):\n pass","def onClose(self, event):\n pass","def closeEvent(self, event):\n self.exit()\n event.accept()","def closeEvent(self, event):\n\n sys.exit()","def closeEvent(self, event: QCloseEvent):\n self.close_signal.emit()","def closeEvent(self, event):\n event.accept() # let the window close\n self.returnHome()","def ev_windowclose(self, event: WindowEvent) -> None:","def closeEvent(self, event):\n self._parent.quit_application(event)","def closeEvent(self, event):\n sys.exit(0)","def onClose (self):\n \n pass","def closeEvent(self, evt):\n self.__shutdown()","def closeEvent(self, event):\r\n self.app.stop()\r\n event.accept()","def on_closing_event(self):\n self.exit_event(None)","def closeEvent(self, event):\n\n\t\tevent.ignore()\n\t\tself.hide()\n\t\tself.__sys_tray_icon.show()","def OnClose(self, event = None):\n ##Close.\n self.Hide()\n self.Destroy()","def onQuit(self, event):\n\n\t\tself.onClose(None)","def closeEvent(self, event):\n if self.mgr.exit_check():\n event.accept()\n else:\n event.ignore()","def closeEvent(self, event):\n if self.mgr.exit_check():\n event.accept()\n else:\n event.ignore()","def closeEvent(self, event): # pylint: disable=invalid-name\n self.cleanup(True)\n event.accept()","def closeEvent(self, event):\n log.info(\"Received window close event.\")\n self.main.app_is_exiting()\n super().closeEvent(event)\n return","def onClose(self, event): \n \n self.Destroy()\n return","def closeEvent(self, event):\n self.stop()\n QtGui.QWidget.closeEvent(self, event)","def closeEvent(self, event):\n aqt.mw.reset()\n super().closeEvent(event)","def OnClose(self, event):\n self._is_open = False\n wx.PostEvent(self, wxDockPaneClosedEvent())","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n super()","def close(event):\n event.widget.destroy()","def _onExit(self, event):\n self.Close(True)","def __window_close(self):\n pass","def closeEvent(self, event):\n logger.info('see here, we can just quit application')\n QtCore.QCoreApplication.quit()","def ev_windowclose(self, event: tcod.event.WindowEvent) -> T | None:","def on_closing(self, *args):\n pass","def closeEvent(self, event):\n print \"Window closed\"\n event.ignore()\n print \"Hide window.\"\n self.subWindow.hide()","def OnClose(self, event):\n self.OnIconize(event, True)","def _close(self, event):\n self.EndModal(wx.ID_OK)","def closeEvent(self, event):\n self.parent.setGeometry(self.geometry[0], self.geometry[1], self.geometry[2], self.geometry[3])\n event.accept()","def OnClose(self, event):\n\n if not self.plot_deleted:\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\n\n print(\"Window: '%s', closed by event: '%s'\" %( self.GetLabel(), event.__class__.__name__ ))\n self.Destroy()","def OnExit(self, event):\r\n self.Close(True)","def closeEvent(self, event):\n w = ExitDialog(self)\n if w.value == -1: # just exit\n self.model.close_nwbfile()\n event.accept()\n elif w.value == 1: # save and exit\n self.AnnotationSave()\n self.IntervalSave()\n self.model.close_nwbfile()\n event.accept()\n elif w.value == 0: # ignore\n event.ignore()","def close(self, **kw) -> None:\n super().close(**kw)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def closeEvent(self, event):\n self.device.disconnect()\n event.accept()","def closeEvent( self, event ):\n # notify any listeners that this RecordEditor has been closed.\n self.closed.emit( self.record[\"id\"] )","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\n # The work-around is to wait a little bit\n time.sleep(0.1)\n super()","def closeEvent(self, event) -> None:\n global dialog\n dialog = None","def handle_close(self):\n self.active = False\n self.close()","def closeEvent(self, event):\r\n self.isWinOpen=False\r\n time.sleep(0.1)\r\n event.accept()","def filemenu_Close(self):\n\n self.on_closing()","def OnClose(self, event):\n\t\tself.Show(False)","def OnClose(self, event):\r\n pos.app.main.Exit()","def closeEvent(self, e):\n QApplication.restoreOverrideCursor()\n e.accept()","def closeEvent(self, event):\n reply = QtWidgets.QMessageBox.question(\n self,\n 'Message',\n \"Are you sure to quit?\",\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\n QtWidgets.QMessageBox.No)\n\n if reply == QtWidgets.QMessageBox.Yes:\n self.onclick_exit()\n event.accept()\n else:\n event.ignore()","def closeEvent(self, event):\n super(MainWindow, self).closeEvent(event)\n try:\n reactor.stop()\n except error.ReactorNotRunning: # if reactor has not been run in the session\n pass","def closeEvent(self, event):\r\n reply = QMessageBox.question(self, 'Message', \"Are you sure to quit?\", QMessageBox.Yes|QMessageBox.No,\r\n QMessageBox.No)\r\n if reply == QMessageBox.Yes:\r\n event.accept()\r\n else:\r\n event.ignore()\r\n return","def on_close(self, event):\n # Save pos and size\n x, y = self.GetPosition()\n width, height = self.GetSize()\n self.__config.set('window.x', x)\n self.__config.set('window.y', y)\n self.__config.set('window.width', width)\n self.__config.set('window.height', height)\n\n # Style\n style = self.GetWindowStyle()\n self.__config.set('window.style', style)\n\n self.__config.save()\n\n # Stop monitoring\n self.__cor.stop_monitor()\n\n # Kill graph as it seems to be stopping script from ending\n self.__graph = None\n\n # End\n event.Skip()","def on_close(self):\n print('[INFO] closing...')\n self.stopEvent.set()\n del self.tello\n self.root.quit()","def close(self):\n raise NotImplementedError(\"Implement this method in child class\")","def _on_close(self):\n self.shell_obj.closed()","def close(self):\r\n pass","def cb_close(self, *args):\n Gtk.main_quit()","def OnClose(self, event):\n self.Show(False)","def onBtnCloseClicked(self):\n self.close()","def closeEvent(self, e):\n self.__diffGenerator.stopProcesses()\n e.accept()","def closeEvent(self, event):\n self._renderer.plotter.close()\n self.close()","def on_close(self, callback):\n self._close_callback = callback","def onCloseWindow(self, event):\r\n\r\n self.Destroy()","def close(self):\n ...","def close(self):\n ...","def handle_close(event):\n self.fig.canvas.stop_event_loop()\n self.raiseAMessage('Closed Figure')","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def close(self):","def on_closing(event=None):\r\n my_msg.set(\"{quit}\")\r\n send()","def close(self):\r\n pass","def close(self):\r\n pass","def close(self):\r\n pass","def closeEvent(self, event):\n if self.confirm_unsaved_changes():\n event.accept()\n else:\n event.ignore()","def on_before_close(self):\n pass","def set_close_callback( callback ):","def closeEvent(self, event):\n self._thread.terminate()\n self._thread.wait()\n event.accept()","def process_IN_CLOSE_WRITE(self, event):","def OnCloseWindow(self, event):\r\n self.data.close()\r\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\r\n self.Destroy()","def Close(self):\n raise NotImplementedError('Implement this')","def close(self):\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n \n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n super().close()","def _onCancel(self):\n\n self.close()","def menuExit(self, event):\n \n self.onClose(event)\n return","def close(self):\n print 'close'","def close(self):\n self.closecallback()\n self.destroy()","def Quit(self, event):\n pass","def closeEvent(self,event):\n\n try:\n if self.globalSession.running:\n event.ignore()\n return\n except:\n pass\n\n\n quit_msg = \"Are you sure you want to exit the program?\"\n reply = QtGui.QMessageBox.question(self, 'Message', \n quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)\n\n if reply == QtGui.QMessageBox.Yes:\n \n self.scanner.stopProcesses()\n self.globalSession.stopProgram = True\n\n try:\n self.globalSession.currentCapture.saveSession()\n self.statusTimer.stop()\n except AttributeError:\n pass # Gets thrown if no captures have been started when closing the program\n\n event.accept()\n else:\n event.ignore()"],"string":"[\n \"def outCloseEvent(self):\\r\\n pass\",\n \"def onClose(self, event):\\n pass\",\n \"def onClose(self, event):\\n pass\",\n \"def onClose(self, event):\\n pass\",\n \"def closeEvent(self, event):\\n self.exit()\\n event.accept()\",\n \"def closeEvent(self, event):\\n\\n sys.exit()\",\n \"def closeEvent(self, event: QCloseEvent):\\n self.close_signal.emit()\",\n \"def closeEvent(self, event):\\n event.accept() # let the window close\\n self.returnHome()\",\n \"def ev_windowclose(self, event: WindowEvent) -> None:\",\n \"def closeEvent(self, event):\\n self._parent.quit_application(event)\",\n \"def closeEvent(self, event):\\n sys.exit(0)\",\n \"def onClose (self):\\n \\n pass\",\n \"def closeEvent(self, evt):\\n self.__shutdown()\",\n \"def closeEvent(self, event):\\r\\n self.app.stop()\\r\\n event.accept()\",\n \"def on_closing_event(self):\\n self.exit_event(None)\",\n \"def closeEvent(self, event):\\n\\n\\t\\tevent.ignore()\\n\\t\\tself.hide()\\n\\t\\tself.__sys_tray_icon.show()\",\n \"def OnClose(self, event = None):\\n ##Close.\\n self.Hide()\\n self.Destroy()\",\n \"def onQuit(self, event):\\n\\n\\t\\tself.onClose(None)\",\n \"def closeEvent(self, event):\\n if self.mgr.exit_check():\\n event.accept()\\n else:\\n event.ignore()\",\n \"def closeEvent(self, event):\\n if self.mgr.exit_check():\\n event.accept()\\n else:\\n event.ignore()\",\n \"def closeEvent(self, event): # pylint: disable=invalid-name\\n self.cleanup(True)\\n event.accept()\",\n \"def closeEvent(self, event):\\n log.info(\\\"Received window close event.\\\")\\n self.main.app_is_exiting()\\n super().closeEvent(event)\\n return\",\n \"def onClose(self, event): \\n \\n self.Destroy()\\n return\",\n \"def closeEvent(self, event):\\n self.stop()\\n QtGui.QWidget.closeEvent(self, event)\",\n \"def closeEvent(self, event):\\n aqt.mw.reset()\\n super().closeEvent(event)\",\n \"def OnClose(self, event):\\n self._is_open = False\\n wx.PostEvent(self, wxDockPaneClosedEvent())\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n super()\",\n \"def close(event):\\n event.widget.destroy()\",\n \"def _onExit(self, event):\\n self.Close(True)\",\n \"def __window_close(self):\\n pass\",\n \"def closeEvent(self, event):\\n logger.info('see here, we can just quit application')\\n QtCore.QCoreApplication.quit()\",\n \"def ev_windowclose(self, event: tcod.event.WindowEvent) -> T | None:\",\n \"def on_closing(self, *args):\\n pass\",\n \"def closeEvent(self, event):\\n print \\\"Window closed\\\"\\n event.ignore()\\n print \\\"Hide window.\\\"\\n self.subWindow.hide()\",\n \"def OnClose(self, event):\\n self.OnIconize(event, True)\",\n \"def _close(self, event):\\n self.EndModal(wx.ID_OK)\",\n \"def closeEvent(self, event):\\n self.parent.setGeometry(self.geometry[0], self.geometry[1], self.geometry[2], self.geometry[3])\\n event.accept()\",\n \"def OnClose(self, event):\\n\\n if not self.plot_deleted:\\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\\n\\n print(\\\"Window: '%s', closed by event: '%s'\\\" %( self.GetLabel(), event.__class__.__name__ ))\\n self.Destroy()\",\n \"def OnExit(self, event):\\r\\n self.Close(True)\",\n \"def closeEvent(self, event):\\n w = ExitDialog(self)\\n if w.value == -1: # just exit\\n self.model.close_nwbfile()\\n event.accept()\\n elif w.value == 1: # save and exit\\n self.AnnotationSave()\\n self.IntervalSave()\\n self.model.close_nwbfile()\\n event.accept()\\n elif w.value == 0: # ignore\\n event.ignore()\",\n \"def close(self, **kw) -> None:\\n super().close(**kw)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def closeEvent(self, event):\\n self.device.disconnect()\\n event.accept()\",\n \"def closeEvent( self, event ):\\n # notify any listeners that this RecordEditor has been closed.\\n self.closed.emit( self.record[\\\"id\\\"] )\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\\n # The work-around is to wait a little bit\\n time.sleep(0.1)\\n super()\",\n \"def closeEvent(self, event) -> None:\\n global dialog\\n dialog = None\",\n \"def handle_close(self):\\n self.active = False\\n self.close()\",\n \"def closeEvent(self, event):\\r\\n self.isWinOpen=False\\r\\n time.sleep(0.1)\\r\\n event.accept()\",\n \"def filemenu_Close(self):\\n\\n self.on_closing()\",\n \"def OnClose(self, event):\\n\\t\\tself.Show(False)\",\n \"def OnClose(self, event):\\r\\n pos.app.main.Exit()\",\n \"def closeEvent(self, e):\\n QApplication.restoreOverrideCursor()\\n e.accept()\",\n \"def closeEvent(self, event):\\n reply = QtWidgets.QMessageBox.question(\\n self,\\n 'Message',\\n \\\"Are you sure to quit?\\\",\\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\\n QtWidgets.QMessageBox.No)\\n\\n if reply == QtWidgets.QMessageBox.Yes:\\n self.onclick_exit()\\n event.accept()\\n else:\\n event.ignore()\",\n \"def closeEvent(self, event):\\n super(MainWindow, self).closeEvent(event)\\n try:\\n reactor.stop()\\n except error.ReactorNotRunning: # if reactor has not been run in the session\\n pass\",\n \"def closeEvent(self, event):\\r\\n reply = QMessageBox.question(self, 'Message', \\\"Are you sure to quit?\\\", QMessageBox.Yes|QMessageBox.No,\\r\\n QMessageBox.No)\\r\\n if reply == QMessageBox.Yes:\\r\\n event.accept()\\r\\n else:\\r\\n event.ignore()\\r\\n return\",\n \"def on_close(self, event):\\n # Save pos and size\\n x, y = self.GetPosition()\\n width, height = self.GetSize()\\n self.__config.set('window.x', x)\\n self.__config.set('window.y', y)\\n self.__config.set('window.width', width)\\n self.__config.set('window.height', height)\\n\\n # Style\\n style = self.GetWindowStyle()\\n self.__config.set('window.style', style)\\n\\n self.__config.save()\\n\\n # Stop monitoring\\n self.__cor.stop_monitor()\\n\\n # Kill graph as it seems to be stopping script from ending\\n self.__graph = None\\n\\n # End\\n event.Skip()\",\n \"def on_close(self):\\n print('[INFO] closing...')\\n self.stopEvent.set()\\n del self.tello\\n self.root.quit()\",\n \"def close(self):\\n raise NotImplementedError(\\\"Implement this method in child class\\\")\",\n \"def _on_close(self):\\n self.shell_obj.closed()\",\n \"def close(self):\\r\\n pass\",\n \"def cb_close(self, *args):\\n Gtk.main_quit()\",\n \"def OnClose(self, event):\\n self.Show(False)\",\n \"def onBtnCloseClicked(self):\\n self.close()\",\n \"def closeEvent(self, e):\\n self.__diffGenerator.stopProcesses()\\n e.accept()\",\n \"def closeEvent(self, event):\\n self._renderer.plotter.close()\\n self.close()\",\n \"def on_close(self, callback):\\n self._close_callback = callback\",\n \"def onCloseWindow(self, event):\\r\\n\\r\\n self.Destroy()\",\n \"def close(self):\\n ...\",\n \"def close(self):\\n ...\",\n \"def handle_close(event):\\n self.fig.canvas.stop_event_loop()\\n self.raiseAMessage('Closed Figure')\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def close(self):\",\n \"def on_closing(event=None):\\r\\n my_msg.set(\\\"{quit}\\\")\\r\\n send()\",\n \"def close(self):\\r\\n pass\",\n \"def close(self):\\r\\n pass\",\n \"def close(self):\\r\\n pass\",\n \"def closeEvent(self, event):\\n if self.confirm_unsaved_changes():\\n event.accept()\\n else:\\n event.ignore()\",\n \"def on_before_close(self):\\n pass\",\n \"def set_close_callback( callback ):\",\n \"def closeEvent(self, event):\\n self._thread.terminate()\\n self._thread.wait()\\n event.accept()\",\n \"def process_IN_CLOSE_WRITE(self, event):\",\n \"def OnCloseWindow(self, event):\\r\\n self.data.close()\\r\\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\\r\\n self.Destroy()\",\n \"def Close(self):\\n raise NotImplementedError('Implement this')\",\n \"def close(self):\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n \\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n super().close()\",\n \"def _onCancel(self):\\n\\n self.close()\",\n \"def menuExit(self, event):\\n \\n self.onClose(event)\\n return\",\n \"def close(self):\\n print 'close'\",\n \"def close(self):\\n self.closecallback()\\n self.destroy()\",\n \"def Quit(self, event):\\n pass\",\n \"def closeEvent(self,event):\\n\\n try:\\n if self.globalSession.running:\\n event.ignore()\\n return\\n except:\\n pass\\n\\n\\n quit_msg = \\\"Are you sure you want to exit the program?\\\"\\n reply = QtGui.QMessageBox.question(self, 'Message', \\n quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)\\n\\n if reply == QtGui.QMessageBox.Yes:\\n \\n self.scanner.stopProcesses()\\n self.globalSession.stopProgram = True\\n\\n try:\\n self.globalSession.currentCapture.saveSession()\\n self.statusTimer.stop()\\n except AttributeError:\\n pass # Gets thrown if no captures have been started when closing the program\\n\\n event.accept()\\n else:\\n event.ignore()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.833176","0.82620287","0.82620287","0.82620287","0.80923194","0.8072515","0.80208814","0.80071384","0.8003962","0.7980135","0.7966298","0.78825104","0.78405327","0.784024","0.78278977","0.77431095","0.7715871","0.77045715","0.77030706","0.77030706","0.76913035","0.76900303","0.76871127","0.76852757","0.76831377","0.7647977","0.7636232","0.7634701","0.7611268","0.75907254","0.7584357","0.7562049","0.75442445","0.75271136","0.752584","0.75167507","0.75094634","0.7472244","0.7472072","0.7464655","0.74248147","0.7420406","0.7420406","0.7420406","0.7420406","0.7415258","0.7349269","0.73485434","0.73444915","0.73355544","0.7318809","0.72819954","0.72672194","0.72639763","0.7233751","0.7227672","0.72265863","0.7208505","0.7207288","0.7200347","0.71997595","0.71924794","0.71865034","0.7181957","0.7177632","0.7172986","0.7158315","0.7135357","0.71316004","0.712989","0.7100512","0.7100512","0.7090102","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.7077551","0.70681316","0.7066697","0.7066697","0.7066697","0.70652795","0.70637226","0.70597637","0.7056725","0.7045554","0.7041618","0.7035138","0.70285803","0.70225036","0.70206547","0.70094466","0.7007606","0.69977355","0.69952893"],"string":"[\n \"0.833176\",\n \"0.82620287\",\n \"0.82620287\",\n \"0.82620287\",\n \"0.80923194\",\n \"0.8072515\",\n \"0.80208814\",\n \"0.80071384\",\n \"0.8003962\",\n \"0.7980135\",\n \"0.7966298\",\n \"0.78825104\",\n \"0.78405327\",\n \"0.784024\",\n \"0.78278977\",\n \"0.77431095\",\n \"0.7715871\",\n \"0.77045715\",\n \"0.77030706\",\n \"0.77030706\",\n \"0.76913035\",\n \"0.76900303\",\n \"0.76871127\",\n \"0.76852757\",\n \"0.76831377\",\n \"0.7647977\",\n \"0.7636232\",\n \"0.7634701\",\n \"0.7611268\",\n \"0.75907254\",\n \"0.7584357\",\n \"0.7562049\",\n \"0.75442445\",\n \"0.75271136\",\n \"0.752584\",\n \"0.75167507\",\n \"0.75094634\",\n \"0.7472244\",\n \"0.7472072\",\n \"0.7464655\",\n \"0.74248147\",\n \"0.7420406\",\n \"0.7420406\",\n \"0.7420406\",\n \"0.7420406\",\n \"0.7415258\",\n \"0.7349269\",\n \"0.73485434\",\n \"0.73444915\",\n \"0.73355544\",\n \"0.7318809\",\n \"0.72819954\",\n \"0.72672194\",\n \"0.72639763\",\n \"0.7233751\",\n \"0.7227672\",\n \"0.72265863\",\n \"0.7208505\",\n \"0.7207288\",\n \"0.7200347\",\n \"0.71997595\",\n \"0.71924794\",\n \"0.71865034\",\n \"0.7181957\",\n \"0.7177632\",\n \"0.7172986\",\n \"0.7158315\",\n \"0.7135357\",\n \"0.71316004\",\n \"0.712989\",\n \"0.7100512\",\n \"0.7100512\",\n \"0.7090102\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.7077551\",\n \"0.70681316\",\n \"0.7066697\",\n \"0.7066697\",\n \"0.7066697\",\n \"0.70652795\",\n \"0.70637226\",\n \"0.70597637\",\n \"0.7056725\",\n \"0.7045554\",\n \"0.7041618\",\n \"0.7035138\",\n \"0.70285803\",\n \"0.70225036\",\n \"0.70206547\",\n \"0.70094466\",\n \"0.7007606\",\n \"0.69977355\",\n \"0.69952893\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9474,"cells":{"query":{"kind":"string","value":"Gets valid user credentials from storage. If nothing has been stored, or if the stored credentials are invalid, the OAuth2 flow is completed to obtain the new credentials."},"document":{"kind":"string","value":"def get_credentials(data_dir_path, client_secret_file_path, scopes, application_name):\n #home_dir = os.path.expanduser('~')\n #credential_dir = os.path.join(home_dir, '.credentials')\n credential_dir = os.path.join(data_dir_path, \".credentials\")\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(client_secret_file_path, scopes)\n flow.user_agent = application_name\n\n try:\n import argparse\n flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()\n except ImportError:\n flags = None\n\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials"},"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 _load_user_credentials(self, storage):\n # Set up a Flow object to be used if we need to authenticate.\n flow = client.flow_from_clientsecrets(\n self.client_secrets,\n scope=self.api_scopes,\n message=tools.message_if_missing(self.client_secrets))\n\n # Retrieve credentials from storage.\n # If the credentials don't exist or are invalid run through the installed\n # client flow. The storage object will ensure that if successful the good\n # credentials will get written back to file.\n\n credentials = storage.get()\n if credentials is None or credentials.invalid:\n credentials = tools.run_flow(flow, storage)\n\n return credentials","def get_credentials(self, **kwargs):\n creds_file = os.path.join(kwargs['user_dir'], 'credentials.json')\n\n # Getting credentials from Storage\n store = file.Storage(creds_file)\n creds = store.get()\n\n # Validating or refreshing credentials, if necessary\n if creds is None or creds.invalid:\n flow = client.flow_from_clientsecrets(self.client_secret_file,\n self.scopes)\n creds = tools.run_flow(flow, store)\n elif creds.access_token_expired:\n creds.refresh(httplib2.Http())\n else:\n pass\n\n return creds","def get_credentials():\n store = Storage(CREDENTIAL_PATH)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store, None)\n return credentials","def authorize_credentials():\n credentials = STORAGE.get()\n # If the credentials doesn't exist in the storage location then run the flow\n if credentials is None or credentials.invalid:\n flow = flow_from_clientsecrets(CREDENTIAL_JSON, scope=SCOPE)\n http = httplib2.Http()\n credentials = run_flow(flow, STORAGE, http=http)\n return credentials","def get_credentials(self):\n home_dir = os.path.expanduser(\"~\")\n credential_dir = os.path.join(home_dir, \".credentials\")\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, \"autoto.json\")\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store, self.auth_flags)\n print(\"Storing credentials to \" + credential_path)\n return credentials","def get_credentials():\n credentials_path = os.path.join(CREDENTIALS_DIR, CREDENTIALS_FILE)\n store = oauth2client.file.Storage(credentials_path)\n credentials = store.locked_get()\n\n if not credentials or credentials.invalid:\n client_secret_path = os.path.join(CREDENTIAL_DIR, CLIENT_SECRET_FILE)\n flow = client.flow_from_clientsecrets(client_secret_path, \n scope='https://www.googleapis.com/auth/admin.directory.resource.calendar',\n redirect_uri='urn:ietf:wg:oauth:2.0:oob')\n\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n\n print(\"Storing credentials to: \" + credentials_path)\n\n\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'clockwise.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatability with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir,\r\n 'bis-python-quickstart.json')\r\n\r\n store = oauth2client.file.Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\r\n flow.user_agent = APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_creds():\n\tcredentials = None\n\tif os.path.exists('token.pickle'):\n\t\twith open('token.pickle', 'rb') as token:\n\t\t\tcredentials = pickle.load(token)\n\t# If there are no (valid) credentials available, let the user log in.\n\tif not credentials or not credentials.valid:\n\t\tif credentials and credentials.expired and credentials.refresh_token:\n\t\t\tcredentials.refresh(Request())\n\t\telse:\n\t\t\tflow = InstalledAppFlow.from_client_secrets_file('config/sa.json', SCOPES)\n\t\t\tcredentials = flow.run_local_server(port=0)\n\t\t# Save the credentials for the next run\n\t\twith open('token.pickle', 'wb') as token:\n\t\t\tpickle.dump(credentials, token)\n\treturn credentials","def get_credentials() -> client.Credentials:\n\n credential_path = os.path.join(HOME_DIR, \"google-credentials.json\")\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(os.path.join(HOME_DIR, CLIENT_SECRET_FILE), SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n # This attempts to open an authorization page in the default web browser, and asks the user\n # to grant the bot access to their data. If the user grants permission, the run_flow()\n # function returns new credentials.\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print(\"Storing credentials to \" + credential_path)","def get_credentials():\n store = Storage(CLIENT_CREDENTIALS_FILE)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + CLIENT_CREDENTIALS_FILE)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'credentialv_modify.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials(self):\r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir, self.CRED_FILENAME)\r\n \r\n store = Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\r\n flow.user_agent = self.APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_credentials():\n credential_dir = os.path.realpath('.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path) # stores the users credentials --> TODO: put in database\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n\n credentials = tools.run_flow(flow, store, flags)\n\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'fb-drive.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_creds():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('inputs/token.pickle'):\n with open('inputs/token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'inputs/credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('inputs/token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n return creds","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'reseller-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_stored_credentials(user_id):\n #\n # To instantiate an OAuth2Credentials instance from a Json\n # representation, use the oauth2client.client.Credentials.new_from_json\n # class method.\n user = engine.query(User).filter(userId=user_id).first()\n if user:\n user_dict = user.__dict__\n if user_dict['credentials']:\n # credentials = Credentials.new_from_json(user['credentials'])\n credentials = json.loads(user_dict['credentials'])\n token_expiry = credentials['token_expiry']\n dexp = parser.parse(str(token_expiry))\n dexp = dexp.replace(tzinfo=None)\n dnow = datetime.now()\n\n if dexp > dnow:\n return Credentials.new_from_json(user_dict['credentials'])\n else:\n status_code, data = renew_access_token(client_id=credentials['client_id'],\n client_secret=credentials['client_secret'],\n refresh_token=credentials['refresh_token'],\n )\n if status_code == INT_OK:\n credentials['access_token'] = data['access_token']\n credentials['token_expiry'] = datetime_util(datetime.now() + timedelta(seconds=float(str(data['expires_in']))))\n credentials = Credentials.new_from_json(json_encode(credentials))\n user.update_credentials(credentials.to_json())\n user.sync()\n return credentials\n else:\n return None\n else:\n return None\n return None","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir,\r\n 'calendar-python-quickstart.json')\r\n\r\n store = oauth2client.file.Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\r\n flow.user_agent = APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_credentials():\r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir,'drive-python-quickstart.json')\r\n\r\n store = Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\r\n flow.user_agent = APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'drive-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'drive-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n\thome_dir = os.path.expanduser('~')\n\tcredential_dir = os.path.join(home_dir, '.credentials')\n\tif not os.path.exists(credential_dir):\n\t\tos.makedirs(credential_dir)\n\tcredential_path = os.path.join(credential_dir, \n\t\t\t\t\t\t\t\t\t'facebook_updater.json')\n\t\t\t\t\t\t\t\t\t\n\tstore = oauth2client.file.Storage(credential_path)\n\tcredentials = store.get()\n\tif not credentials or credentials.invalid:\n\t\tflow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n\t\tflow.user_agent = APPLICATION_NAME\n\t\tif flags:\n\t\t\tcredentials = tools.run_flow(flow, store, flags)\n\t\tprint ('Storing credentials to ' + credential_path)\n\treturn credentials","def get_credentials():\n credential_dir = os.getcwd()\n credential_path = os.path.join(credential_dir,\n 'smarking_error_check.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'client_secret_OCR.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n print(\"Current folder: \" + os.getcwd())\n flow = client.flow_from_clientsecrets(\n \"../../\" + CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatability with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'grader.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store, tools.argparser.parse_args(args=[]))\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'google-photos-stats.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store, flags)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'appsactivity-python-showtime.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n print('Storing credentials to ' + credential_path)\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'admin-directory_v1-NestedGroupSync.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatability with Python 2.6\n credentials = tools.run(flow, store)\n print 'Storing credentials to' + credential_path\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'thejam_calendar.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(config['client secret file'], SCOPES)\n flow.user_agent = APPLICATION_NAME\n if args:\n credentials = tools.run_flow(flow, store, args)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sally.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n #home_dir = os.path.expanduser('~')\n home_dir = os.path.expanduser('/home/pi/')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'gmail-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir,\r\n 'gmail-python-spam-filter.json')\r\n\r\n store = Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\r\n flow.user_agent = APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_auth_token(self):\n creds = None\n # The file token.pickle stores the user's access and refresh tokens,\n # and is created automatically when the authorization flow completes\n # for the first time.\n if os.path.exists(self.token_path):\n with open(self.token_path, 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n self.credentials_path, self.scopes)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open(self.token_path, 'wb') as token:\n pickle.dump(creds, token)\n return creds","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(args.clientSecretFile, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if args:\n credentials = tools.run_flow(flow, store, args)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def _get_credentials(self):\n\n scopes = 'https://www.googleapis.com/auth/drive'\n client_secret_file = '%s/config/client_secret.json' % PROJECT_DIR\n application_name = 'Drive API Quickstart'\n\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n\n credential_path = os.path.join(credential_dir, 'drive-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\n flow.user_agent = application_name\n\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatability with Python 2.6\n credentials = tools.run(flow, store)\n\n return credentials","def get_credentials(self):\n #\n # Why is this not read from the yaml file?\n path = Path(path_expand(self.credential_file)).resolve()\n if not os.path.exists(path):\n os.makedirs(path)\n\n credentials_path = (path / 'google-drive-credentials.json').resolve()\n print(credentials_path)\n\n store = Storage(credentials_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(self.client_secret_file,\n self.scopes)\n flow.user_agent = self.application_name\n #\n # SHOUDL THE FLAGS NOT BE SET IN THE YAML FILE OR DOCOPTS OFTHE COMMAND?\n #\n if self.flags:\n credentials = tools.run_flow(flow, store, self.flags)\n\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = './ignore' #os.path.expanduser('./')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = './ignore' #os.path.expanduser('./')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials(self):\n home_dir = os.path.expanduser('~')\n # credential_dir = os.path.join(home_dir, '.credentials')\n credential_dir = '.credentials'\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'drive-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(GoogleDocsConverter.CLIENT_SECRET_FILE, GoogleDocsConverter.SCOPES)\n flow.user_agent = GoogleDocsConverter.APPLICATION_NAME\n if self.flags:\n credentials = tools.run_flow(flow, store, self.flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser(os.getcwd())\n credential_dir = os.path.join(home_dir, '.credentials')\n print(credential_dir)\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_creds():\n # If modifying these scopes, delete the file token.pickle.\n SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']\n creds = None\n dir_pre = '../secrets'\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n logging.debug(f\"searching for creds in path: {os.getcwd()}\")\n if os.path.exists(os.path.join(dir_pre, 'token.pickle')):\n with open(os.path.join(dir_pre, 'token.pickle'), 'rb') as token:\n creds = pickle.load(token)\n logging.info('opening token.pickle')\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n logging.info('token expired, refreshing token')\n creds.refresh(Request())\n else:\n logging.info('token not found, re authenticating ')\n flow = InstalledAppFlow.from_client_secrets_file(os.path.join(dir_pre, 'credentials.json'), SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open(os.path.join(dir_pre, 'token.pickle'), 'wb') as token:\n pickle.dump(creds, token)\n\n return creds","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(\n credential_dir, 'sheets.googleapis.com-python-quickstart.json'\n )\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(resource_path(CLIENT_SECRET_FILE), SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials(self):\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'homework_logger-gmail-api.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\n flow.user_agent = self.APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def getCredentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'gmail-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def getCredentials(scopes):\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,'admin-directory_v1-python-quickstart.json')\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, scopes)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials(self):\r\n \r\n try:\r\n import argparse\r\n #flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()\r\n if self.noauth == True:\r\n flags = tools.argparser.parse_args(args=['--noauth_local_webserver'])\r\n else:\r\n flags = tools.argparser.parse_args(args=[])\r\n except ImportError:\r\n flags = None \r\n \r\n home_dir = os.path.expanduser('~')\r\n credential_dir = os.path.join(home_dir, '.credentials')\r\n if not os.path.exists(credential_dir):\r\n os.makedirs(credential_dir)\r\n credential_path = os.path.join(credential_dir,'sheets.googleapis.com-allstarbot.json')\r\n\r\n store = Storage(credential_path)\r\n credentials = store.get()\r\n if not credentials or credentials.invalid:\r\n secret = Path(self.CLIENT_SECRET_FILE)\r\n if secret.exists():\r\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\r\n else:\r\n print(\"client_secret.json not found, using env vars\")\r\n if not os.environ.get('client_id') or not os.environ.get('client_secret'): \r\n print(\"env vars client_id and client_secret not found. canceling\")\r\n raise Exception(\"client secret error\")\r\n else:\r\n flow = OAuth2WebServerFlow(\r\n os.environ.get('client_id'),\r\n os.environ.get('client_secret'),\r\n self.SCOPES) \r\n \r\n flow.params['access_type'] = 'offline'\r\n flow.user_agent = self.APPLICATION_NAME\r\n if flags:\r\n credentials = tools.run_flow(flow, store, flags)\r\n else: # Needed only for compatibility with Python 2.6\r\n credentials = tools.run(flow, store)\r\n print('Storing credentials to ' + credential_path)\r\n return credentials","def get_credentials(credentials_filename, application_name, client_secret_file, scopes):\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n credentials_filename)\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\n flow.user_agent = application_name\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n# else: # Needed only for compatibility with Python 2.6\n# credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def valid_credentials():\n if 'credentials' not in flask.session:\n return None\n\n credentials = client.OAuth2Credentials.from_json(\n flask.session['credentials'])\n\n if (credentials.invalid or\n credentials.access_token_expired):\n return None\n return credentials","def valid_credentials():\n if 'credentials' not in flask.session:\n return None\n\n credentials = client.OAuth2Credentials.from_json(\n flask.session['credentials'])\n\n if (credentials.invalid or\n credentials.access_token_expired):\n return None\n return credentials","def __create_credentials(self, scopes):\n creds = None\n\n # The File token.pickle stores the user's access and refresh tokens,\n # and is created automatically whne the flow compleates for the first time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # if there are no valid credentials available, let the user log in\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', scopes)\n creds = flow.run_local_server(port=0)\n # save the creds for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n return creds","def get_credentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.logSheets.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n print('Storing credentials to ' + credential_path)\n return credentials","def authenticate():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'google-drive-credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n return creds","def getUsrCreds(self):\n import pickle\n import os.path\n from google_auth_oauthlib.flow import InstalledAppFlow\n from google.auth.transport.requests import Request\n\n # If modifying these scopes, delete the file token.pickle.\n SCOPES = ['https://www.googleapis.com/auth/calendar']\n\n self.creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as self.token:\n self.creds = pickle.load(self.token)\n # If there are no (valid) credentials available, let the user log in.\n if not self.creds or not self.creds.valid:\n if self.creds and self.creds.expired and self.creds.refresh_token:\n self.creds.refresh(Request())\n else:\n self.flow = InstalledAppFlow.from_client_secrets_file(\n 'client_secret.json', scopes = SCOPES)\n self.creds = self.flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as self.token:\n pickle.dump(self.creds, self.token)\n\n return self.creds","def get_credentials(self):\n if getattr(self, 'credentials', None):\n return self.credentials\n\n scopes = settings.SCOPES\n client_secret_file = settings.CLIENT_SECRET_FILE\n application_name = 'Google Sheets API Python Quickstart'\n\n home_dir = os.path.expanduser(settings.CREDENTIALS_DIRECTORY)\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\n flow.user_agent = application_name\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n # print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n try:\n import argparse\n flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()\n except ImportError:\n flags = None\n\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'appsactivity-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(GoogleGsuiteAPI.CLIENT_SECRET_FILE, GoogleGsuiteAPI.SCOPES)\n flow.user_agent = GoogleGsuiteAPI.APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def create_credentials():\r\n creds = None\r\n # The file token.pickle stores the user's access and refresh tokens, and is\r\n # created automatically when the authorization flow completes for the first\r\n # time.\r\n if os.path.exists('token.pickle'):\r\n with open('token.pickle', 'rb') as token:\r\n creds = pickle.load(token)\r\n # If there are no (valid) credentials available, let the user log in.\r\n if not creds or not creds.valid:\r\n if creds and creds.expired and creds.refresh_token:\r\n creds.refresh(Request())\r\n else:\r\n flow = InstalledAppFlow.from_client_secrets_file(\r\n 'client_secret.json', SCOPES)\r\n creds = flow.run_local_server()\r\n # Save the credentials for the next run\r\n with open('token.pickle', 'wb') as token:\r\n pickle.dump(creds, token)\r\n return creds","def get_stored_credentials(user):\n with open(\"access.json\", \"r\") as f:\n credentials = json.load(f)\n user_creds = credentials[user]\n return user_creds[\"access_token\"], user_creds[\"access_secret\"]","def get_credentials(scopes=None, secrets=None, storage=None, *,\n no_webserver=False):\n scopes = Scopes.get(scopes)\n\n if secrets is None:\n secrets = SECRETS\n if storage is None:\n storage = STORAGE\n\n secrets, storage = map(os.path.expanduser, (secrets, storage))\n\n store = file.Storage(storage)\n creds = store.get()\n\n if creds is None or creds.invalid:\n flow = client.flow_from_clientsecrets(secrets, scopes)\n args = ['--noauth_local_webserver'] if no_webserver else []\n flags = tools.argparser.parse_args(args)\n creds = tools.run_flow(flow, store, flags)\n\n return creds","def valid_credentials():\n if 'credentials' not in flask.session:\n return None\n\n credentials = client.OAuth2Credentials.from_json(\n flask.session['credentials'])\n\n if (credentials.invalid or credentials.access_token_expired):\n return None\n return credentials","def get_credentials(client_secrets='client_secrets.json',\n scope_='https://www.googleapis.com/auth/drive',\n redirect_uri_='http://localhost:8080'):\n flow = client.flow_from_clientsecrets(client_secrets,\n scope=scope_,\n redirect_uri=redirect_uri_)\n credentials = tools.run_flow(flow, Store(), None)\n return credentials","def get_credentials(account):\n credential_dir = os.path.join(HOME_DIR, META_DIR, account, \"credentials\")\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir, 'pyDrive.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_creds(\n user=\"default\", config=None, scope=default_scope, creds_dir=None, save=True\n):\n config = config or get_config()\n try:\n if \"private_key_id\" in config:\n return SACredentials.from_service_account_info(config, scopes=scope)\n\n if not isinstance(user, str):\n raise ConfigException(\n \"Need to provide a user key as a string if not using a service account\"\n )\n\n if creds_dir is None:\n creds_dir = get_config_dir() / \"creds\"\n\n creds_file = Path(creds_dir) / user\n\n if creds_file.exists():\n # need to convert Path to string for python 2.7\n return OAuthCredentials.from_authorized_user_file(str(creds_file))\n\n flow = InstalledAppFlow.from_client_config(config, scope)\n creds = flow.run_local_server(\n host=\"localhost\",\n port=8182,\n authorization_prompt_message=\"Please visit this URL: {url}\",\n success_message=\"The auth flow is complete; you may close this window.\",\n open_browser=False,\n )\n\n if save:\n creds_data = {\n \"refresh_token\": creds.refresh_token,\n \"token_uri\": creds.token_uri,\n \"client_id\": creds.client_id,\n \"client_secret\": creds.client_secret,\n \"scopes\": creds.scopes,\n }\n\n ensure_path(creds_dir)\n creds_file.write_text(decode(json.dumps(creds_data)))\n\n return creds\n except Exception:\n exc_info = sys.exc_info()\n raise ConfigException(*exc_info[1:])","def get_credentials():\n #home_dir = os.path.expanduser('~')\n home_dir = (HOME_DIR)\n credential_dir = os.path.join(home_dir, '.credentials')\n print(\"Credentials folder: \",credential_dir)\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'sheets.googleapis.com-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def GetCredentials(self, credentials_path: str,\n client_secrets_path: str) -> Optional[Any]:\n scopes = ['openid', 'https://www.googleapis.com/auth/userinfo.email']\n credentials = None\n\n # Load credentials file if it exists\n if os.path.exists(credentials_path):\n try:\n credentials = Credentials.from_authorized_user_file(\n credentials_path, scopes)\n except ValueError as exception:\n msg = f'Error loading credentials: {exception!s}'\n self.ModuleError(msg, critical=True)\n # Refresh credentials using existing refresh_token\n if credentials and credentials.refresh_token:\n self.logger.debug('Found a refresh token. Requesting new id_token...')\n try:\n credentials.refresh(Request())\n except google_exceptions.RefreshError as exception:\n self.logger.debug(f'Error refreshing credentials: {exception!s}')\n else:\n # No credentials file, acquire new credentials from secrets file.\n self.logger.debug(\n 'Could not find existing credentials. Requesting new tokens.')\n try:\n appflow = flow.InstalledAppFlow.from_client_secrets_file(\n client_secrets_path, scopes)\n except FileNotFoundError as exception:\n msg = f'Client secrets file not found: {exception!s}'\n self.ModuleError(msg, critical=True)\n\n self.logger.info(\n 'Starting local HTTP server on localhost:8888 for OAUTH flow. '\n 'If running dftimewolf remotely over SSH you will need to tunnel '\n 'port 8888.')\n appflow.run_local_server(host='localhost', port=8888, open_browser=False)\n credentials = appflow.credentials\n\n # Save credentials\n if credentials:\n with open(credentials_path, 'w', encoding='utf-8') as token:\n token.write(credentials.to_json())\n\n return credentials","def get_credentials(commandline_flags=None):\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'drive-python-quickstart.json')\n\n store = oauth2client.file.Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if commandline_flags:\n credentials = tools.run_flow(flow, store, commandline_flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get_credentials():\n credential_dir = os.path.dirname(os.path.realpath(CLIENT_SECRET_FILE))\n credential_path = os.path.join(\n credential_dir, 'sheets.googleapis.com-endosys-events.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def acquire_oauth2_credentials():\n if os.path.isfile(\"%s/cre.json\" % file_path):\n f = open(\"%s/cre.json\" % file_path, \"r\")\n credentials = client.OAuth2Credentials.from_json(f.read())\n f.close()\n else: \n flow = client.flow_from_clientsecrets(\n \"%s/client_secrets.json\" % file_path,\n scope='https://www.googleapis.com/auth/analytics.readonly',\n redirect_uri='urn:ietf:wg:oauth:2.0:oob')\n auth_uri = flow.step1_get_authorize_url()\n webbrowser.open(auth_uri)\n auth_code = input('Enter the authentication code: ')\n credentials = flow.step2_exchange(auth_code)\n write_credentials(\"%s/cre.json\" % file_path, credentials)\n return credentials","def google_creds() -> object:\n # If modifying these scopes, delete the file token.pickle.\n SCOPES = ['https://www.googleapis.com/auth/drive.file',\n 'https://www.googleapis.com/auth/drive',\n 'https://www.googleapis.com/auth/drive.activity',\n 'https://www.googleapis.com/auth/spreadsheets'\n ]\n\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n return creds","def get_credentials(args, my_dirname):\n\n credential_dir = os.path.join(my_dirname, '.credentials')\n if not os.path.exists(credential_dir):\n os.mkdir(credential_dir)\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-cotus-checker.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n try:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n credentials = tools.run_flow(flow, store, args)\n print('Storing credentials to ' + credential_path)\n except (oauth2client.clientsecrets.InvalidClientSecretsError, json.decoder.JSONDecodeError):\n pass\n return credentials","def get_GoogleCredentials():\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'calendar-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def _get_credential(self):\n creds = None\n\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', self.config['SCOPES'])\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n self.service = build('drive', 'v3', credentials=creds)","def get_credentials( flags=None ):\n home_dir = os.path.expanduser('~')\n credential_dir = os.path.join(home_dir, '.credentials')\n if not os.path.exists(credential_dir):\n os.makedirs(credential_dir)\n credential_path = os.path.join(credential_dir,\n 'drive-python-quickstart.json')\n\n store = Storage(credential_path)\n credentials = store.get()\n if not credentials or credentials.invalid:\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\n flow.user_agent = APPLICATION_NAME\n if flags:\n credentials = tools.run_flow(flow, store, flags)\n else: # Needed only for compatibility with Python 2.6\n credentials = tools.run(flow, store)\n print('Storing credentials to ' + credential_path)\n return credentials","def get(self):\n self._lock.acquire()\n try:\n f = open(self._filename, 'r')\n credentials = pickle.loads(f.read())\n f.close()\n credentials.set_store(self.put)\n except:\n credentials = None\n self._lock.release()\n\n return credentials","def get_creds(\n config: Config=default):\n config_path = config.credential_path\n scopes = config.scopes\n\n logger.info('loading token')\n logger.debug(f'config_path: {config_path}')\n config_path = Path(config_path).expanduser()\n store = file.Storage(config_path/'token.json')\n creds = store.get()\n\n if not creds or creds.invalid:\n # Ask the user to give the correct permissions.\n logger.info('loading credentials')\n flow = client.flow_from_clientsecrets(\n config_path/'client_id.json',\n scopes)\n\n arguments = sys.argv\n sys.argv = sys.argv[0:1]\n # This line is why we need to remove the arguments from sys.argv\n # If you find a better way to get it to work, i'm buying it\n creds = tools.run_flow(flow, store)\n sys.argv = arguments\n\n return creds"],"string":"[\n \"def _load_user_credentials(self, storage):\\n # Set up a Flow object to be used if we need to authenticate.\\n flow = client.flow_from_clientsecrets(\\n self.client_secrets,\\n scope=self.api_scopes,\\n message=tools.message_if_missing(self.client_secrets))\\n\\n # Retrieve credentials from storage.\\n # If the credentials don't exist or are invalid run through the installed\\n # client flow. The storage object will ensure that if successful the good\\n # credentials will get written back to file.\\n\\n credentials = storage.get()\\n if credentials is None or credentials.invalid:\\n credentials = tools.run_flow(flow, storage)\\n\\n return credentials\",\n \"def get_credentials(self, **kwargs):\\n creds_file = os.path.join(kwargs['user_dir'], 'credentials.json')\\n\\n # Getting credentials from Storage\\n store = file.Storage(creds_file)\\n creds = store.get()\\n\\n # Validating or refreshing credentials, if necessary\\n if creds is None or creds.invalid:\\n flow = client.flow_from_clientsecrets(self.client_secret_file,\\n self.scopes)\\n creds = tools.run_flow(flow, store)\\n elif creds.access_token_expired:\\n creds.refresh(httplib2.Http())\\n else:\\n pass\\n\\n return creds\",\n \"def get_credentials():\\n store = Storage(CREDENTIAL_PATH)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store, None)\\n return credentials\",\n \"def authorize_credentials():\\n credentials = STORAGE.get()\\n # If the credentials doesn't exist in the storage location then run the flow\\n if credentials is None or credentials.invalid:\\n flow = flow_from_clientsecrets(CREDENTIAL_JSON, scope=SCOPE)\\n http = httplib2.Http()\\n credentials = run_flow(flow, STORAGE, http=http)\\n return credentials\",\n \"def get_credentials(self):\\n home_dir = os.path.expanduser(\\\"~\\\")\\n credential_dir = os.path.join(home_dir, \\\".credentials\\\")\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, \\\"autoto.json\\\")\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store, self.auth_flags)\\n print(\\\"Storing credentials to \\\" + credential_path)\\n return credentials\",\n \"def get_credentials():\\n credentials_path = os.path.join(CREDENTIALS_DIR, CREDENTIALS_FILE)\\n store = oauth2client.file.Storage(credentials_path)\\n credentials = store.locked_get()\\n\\n if not credentials or credentials.invalid:\\n client_secret_path = os.path.join(CREDENTIAL_DIR, CLIENT_SECRET_FILE)\\n flow = client.flow_from_clientsecrets(client_secret_path, \\n scope='https://www.googleapis.com/auth/admin.directory.resource.calendar',\\n redirect_uri='urn:ietf:wg:oauth:2.0:oob')\\n\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n\\n print(\\\"Storing credentials to: \\\" + credentials_path)\\n\\n\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'clockwise.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatability with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir,\\r\\n 'bis-python-quickstart.json')\\r\\n\\r\\n store = oauth2client.file.Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\r\\n flow.user_agent = APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_creds():\\n\\tcredentials = None\\n\\tif os.path.exists('token.pickle'):\\n\\t\\twith open('token.pickle', 'rb') as token:\\n\\t\\t\\tcredentials = pickle.load(token)\\n\\t# If there are no (valid) credentials available, let the user log in.\\n\\tif not credentials or not credentials.valid:\\n\\t\\tif credentials and credentials.expired and credentials.refresh_token:\\n\\t\\t\\tcredentials.refresh(Request())\\n\\t\\telse:\\n\\t\\t\\tflow = InstalledAppFlow.from_client_secrets_file('config/sa.json', SCOPES)\\n\\t\\t\\tcredentials = flow.run_local_server(port=0)\\n\\t\\t# Save the credentials for the next run\\n\\t\\twith open('token.pickle', 'wb') as token:\\n\\t\\t\\tpickle.dump(credentials, token)\\n\\treturn credentials\",\n \"def get_credentials() -> client.Credentials:\\n\\n credential_path = os.path.join(HOME_DIR, \\\"google-credentials.json\\\")\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(os.path.join(HOME_DIR, CLIENT_SECRET_FILE), SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n # This attempts to open an authorization page in the default web browser, and asks the user\\n # to grant the bot access to their data. If the user grants permission, the run_flow()\\n # function returns new credentials.\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print(\\\"Storing credentials to \\\" + credential_path)\",\n \"def get_credentials():\\n store = Storage(CLIENT_CREDENTIALS_FILE)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + CLIENT_CREDENTIALS_FILE)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'credentialv_modify.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials(self):\\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir, self.CRED_FILENAME)\\r\\n \\r\\n store = Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\\r\\n flow.user_agent = self.APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_credentials():\\n credential_dir = os.path.realpath('.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path) # stores the users credentials --> TODO: put in database\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n\\n credentials = tools.run_flow(flow, store, flags)\\n\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'fb-drive.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_creds():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('inputs/token.pickle'):\\n with open('inputs/token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'inputs/credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('inputs/token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n return creds\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'reseller-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_stored_credentials(user_id):\\n #\\n # To instantiate an OAuth2Credentials instance from a Json\\n # representation, use the oauth2client.client.Credentials.new_from_json\\n # class method.\\n user = engine.query(User).filter(userId=user_id).first()\\n if user:\\n user_dict = user.__dict__\\n if user_dict['credentials']:\\n # credentials = Credentials.new_from_json(user['credentials'])\\n credentials = json.loads(user_dict['credentials'])\\n token_expiry = credentials['token_expiry']\\n dexp = parser.parse(str(token_expiry))\\n dexp = dexp.replace(tzinfo=None)\\n dnow = datetime.now()\\n\\n if dexp > dnow:\\n return Credentials.new_from_json(user_dict['credentials'])\\n else:\\n status_code, data = renew_access_token(client_id=credentials['client_id'],\\n client_secret=credentials['client_secret'],\\n refresh_token=credentials['refresh_token'],\\n )\\n if status_code == INT_OK:\\n credentials['access_token'] = data['access_token']\\n credentials['token_expiry'] = datetime_util(datetime.now() + timedelta(seconds=float(str(data['expires_in']))))\\n credentials = Credentials.new_from_json(json_encode(credentials))\\n user.update_credentials(credentials.to_json())\\n user.sync()\\n return credentials\\n else:\\n return None\\n else:\\n return None\\n return None\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir,\\r\\n 'calendar-python-quickstart.json')\\r\\n\\r\\n store = oauth2client.file.Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\r\\n flow.user_agent = APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_credentials():\\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir,'drive-python-quickstart.json')\\r\\n\\r\\n store = Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\r\\n flow.user_agent = APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'drive-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'drive-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n\\thome_dir = os.path.expanduser('~')\\n\\tcredential_dir = os.path.join(home_dir, '.credentials')\\n\\tif not os.path.exists(credential_dir):\\n\\t\\tos.makedirs(credential_dir)\\n\\tcredential_path = os.path.join(credential_dir, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t'facebook_updater.json')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\tstore = oauth2client.file.Storage(credential_path)\\n\\tcredentials = store.get()\\n\\tif not credentials or credentials.invalid:\\n\\t\\tflow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n\\t\\tflow.user_agent = APPLICATION_NAME\\n\\t\\tif flags:\\n\\t\\t\\tcredentials = tools.run_flow(flow, store, flags)\\n\\t\\tprint ('Storing credentials to ' + credential_path)\\n\\treturn credentials\",\n \"def get_credentials():\\n credential_dir = os.getcwd()\\n credential_path = os.path.join(credential_dir,\\n 'smarking_error_check.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'client_secret_OCR.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n print(\\\"Current folder: \\\" + os.getcwd())\\n flow = client.flow_from_clientsecrets(\\n \\\"../../\\\" + CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatability with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'grader.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store, tools.argparser.parse_args(args=[]))\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'google-photos-stats.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store, flags)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'appsactivity-python-showtime.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n print('Storing credentials to ' + credential_path)\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'admin-directory_v1-NestedGroupSync.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatability with Python 2.6\\n credentials = tools.run(flow, store)\\n print 'Storing credentials to' + credential_path\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'thejam_calendar.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(config['client secret file'], SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if args:\\n credentials = tools.run_flow(flow, store, args)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sally.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n #home_dir = os.path.expanduser('~')\\n home_dir = os.path.expanduser('/home/pi/')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'gmail-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir,\\r\\n 'gmail-python-spam-filter.json')\\r\\n\\r\\n store = Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\r\\n flow.user_agent = APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_auth_token(self):\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens,\\n # and is created automatically when the authorization flow completes\\n # for the first time.\\n if os.path.exists(self.token_path):\\n with open(self.token_path, 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n self.credentials_path, self.scopes)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open(self.token_path, 'wb') as token:\\n pickle.dump(creds, token)\\n return creds\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(args.clientSecretFile, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if args:\\n credentials = tools.run_flow(flow, store, args)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def _get_credentials(self):\\n\\n scopes = 'https://www.googleapis.com/auth/drive'\\n client_secret_file = '%s/config/client_secret.json' % PROJECT_DIR\\n application_name = 'Drive API Quickstart'\\n\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n\\n credential_path = os.path.join(credential_dir, 'drive-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\\n flow.user_agent = application_name\\n\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatability with Python 2.6\\n credentials = tools.run(flow, store)\\n\\n return credentials\",\n \"def get_credentials(self):\\n #\\n # Why is this not read from the yaml file?\\n path = Path(path_expand(self.credential_file)).resolve()\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n credentials_path = (path / 'google-drive-credentials.json').resolve()\\n print(credentials_path)\\n\\n store = Storage(credentials_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(self.client_secret_file,\\n self.scopes)\\n flow.user_agent = self.application_name\\n #\\n # SHOUDL THE FLAGS NOT BE SET IN THE YAML FILE OR DOCOPTS OFTHE COMMAND?\\n #\\n if self.flags:\\n credentials = tools.run_flow(flow, store, self.flags)\\n\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = './ignore' #os.path.expanduser('./')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = './ignore' #os.path.expanduser('./')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials(self):\\n home_dir = os.path.expanduser('~')\\n # credential_dir = os.path.join(home_dir, '.credentials')\\n credential_dir = '.credentials'\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'drive-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(GoogleDocsConverter.CLIENT_SECRET_FILE, GoogleDocsConverter.SCOPES)\\n flow.user_agent = GoogleDocsConverter.APPLICATION_NAME\\n if self.flags:\\n credentials = tools.run_flow(flow, store, self.flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser(os.getcwd())\\n credential_dir = os.path.join(home_dir, '.credentials')\\n print(credential_dir)\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_creds():\\n # If modifying these scopes, delete the file token.pickle.\\n SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']\\n creds = None\\n dir_pre = '../secrets'\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n logging.debug(f\\\"searching for creds in path: {os.getcwd()}\\\")\\n if os.path.exists(os.path.join(dir_pre, 'token.pickle')):\\n with open(os.path.join(dir_pre, 'token.pickle'), 'rb') as token:\\n creds = pickle.load(token)\\n logging.info('opening token.pickle')\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n logging.info('token expired, refreshing token')\\n creds.refresh(Request())\\n else:\\n logging.info('token not found, re authenticating ')\\n flow = InstalledAppFlow.from_client_secrets_file(os.path.join(dir_pre, 'credentials.json'), SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open(os.path.join(dir_pre, 'token.pickle'), 'wb') as token:\\n pickle.dump(creds, token)\\n\\n return creds\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(\\n credential_dir, 'sheets.googleapis.com-python-quickstart.json'\\n )\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(resource_path(CLIENT_SECRET_FILE), SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials(self):\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'homework_logger-gmail-api.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\\n flow.user_agent = self.APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def getCredentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'gmail-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def getCredentials(scopes):\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,'admin-directory_v1-python-quickstart.json')\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, scopes)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials(self):\\r\\n \\r\\n try:\\r\\n import argparse\\r\\n #flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()\\r\\n if self.noauth == True:\\r\\n flags = tools.argparser.parse_args(args=['--noauth_local_webserver'])\\r\\n else:\\r\\n flags = tools.argparser.parse_args(args=[])\\r\\n except ImportError:\\r\\n flags = None \\r\\n \\r\\n home_dir = os.path.expanduser('~')\\r\\n credential_dir = os.path.join(home_dir, '.credentials')\\r\\n if not os.path.exists(credential_dir):\\r\\n os.makedirs(credential_dir)\\r\\n credential_path = os.path.join(credential_dir,'sheets.googleapis.com-allstarbot.json')\\r\\n\\r\\n store = Storage(credential_path)\\r\\n credentials = store.get()\\r\\n if not credentials or credentials.invalid:\\r\\n secret = Path(self.CLIENT_SECRET_FILE)\\r\\n if secret.exists():\\r\\n flow = client.flow_from_clientsecrets(self.CLIENT_SECRET_FILE, self.SCOPES)\\r\\n else:\\r\\n print(\\\"client_secret.json not found, using env vars\\\")\\r\\n if not os.environ.get('client_id') or not os.environ.get('client_secret'): \\r\\n print(\\\"env vars client_id and client_secret not found. canceling\\\")\\r\\n raise Exception(\\\"client secret error\\\")\\r\\n else:\\r\\n flow = OAuth2WebServerFlow(\\r\\n os.environ.get('client_id'),\\r\\n os.environ.get('client_secret'),\\r\\n self.SCOPES) \\r\\n \\r\\n flow.params['access_type'] = 'offline'\\r\\n flow.user_agent = self.APPLICATION_NAME\\r\\n if flags:\\r\\n credentials = tools.run_flow(flow, store, flags)\\r\\n else: # Needed only for compatibility with Python 2.6\\r\\n credentials = tools.run(flow, store)\\r\\n print('Storing credentials to ' + credential_path)\\r\\n return credentials\",\n \"def get_credentials(credentials_filename, application_name, client_secret_file, scopes):\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n credentials_filename)\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\\n flow.user_agent = application_name\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n# else: # Needed only for compatibility with Python 2.6\\n# credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def valid_credentials():\\n if 'credentials' not in flask.session:\\n return None\\n\\n credentials = client.OAuth2Credentials.from_json(\\n flask.session['credentials'])\\n\\n if (credentials.invalid or\\n credentials.access_token_expired):\\n return None\\n return credentials\",\n \"def valid_credentials():\\n if 'credentials' not in flask.session:\\n return None\\n\\n credentials = client.OAuth2Credentials.from_json(\\n flask.session['credentials'])\\n\\n if (credentials.invalid or\\n credentials.access_token_expired):\\n return None\\n return credentials\",\n \"def __create_credentials(self, scopes):\\n creds = None\\n\\n # The File token.pickle stores the user's access and refresh tokens,\\n # and is created automatically whne the flow compleates for the first time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # if there are no valid credentials available, let the user log in\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', scopes)\\n creds = flow.run_local_server(port=0)\\n # save the creds for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n return creds\",\n \"def get_credentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.logSheets.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def authenticate():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'google-drive-credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n return creds\",\n \"def getUsrCreds(self):\\n import pickle\\n import os.path\\n from google_auth_oauthlib.flow import InstalledAppFlow\\n from google.auth.transport.requests import Request\\n\\n # If modifying these scopes, delete the file token.pickle.\\n SCOPES = ['https://www.googleapis.com/auth/calendar']\\n\\n self.creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as self.token:\\n self.creds = pickle.load(self.token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not self.creds or not self.creds.valid:\\n if self.creds and self.creds.expired and self.creds.refresh_token:\\n self.creds.refresh(Request())\\n else:\\n self.flow = InstalledAppFlow.from_client_secrets_file(\\n 'client_secret.json', scopes = SCOPES)\\n self.creds = self.flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as self.token:\\n pickle.dump(self.creds, self.token)\\n\\n return self.creds\",\n \"def get_credentials(self):\\n if getattr(self, 'credentials', None):\\n return self.credentials\\n\\n scopes = settings.SCOPES\\n client_secret_file = settings.CLIENT_SECRET_FILE\\n application_name = 'Google Sheets API Python Quickstart'\\n\\n home_dir = os.path.expanduser(settings.CREDENTIALS_DIRECTORY)\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(client_secret_file, scopes)\\n flow.user_agent = application_name\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n # print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n try:\\n import argparse\\n flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()\\n except ImportError:\\n flags = None\\n\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'appsactivity-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(GoogleGsuiteAPI.CLIENT_SECRET_FILE, GoogleGsuiteAPI.SCOPES)\\n flow.user_agent = GoogleGsuiteAPI.APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def create_credentials():\\r\\n creds = None\\r\\n # The file token.pickle stores the user's access and refresh tokens, and is\\r\\n # created automatically when the authorization flow completes for the first\\r\\n # time.\\r\\n if os.path.exists('token.pickle'):\\r\\n with open('token.pickle', 'rb') as token:\\r\\n creds = pickle.load(token)\\r\\n # If there are no (valid) credentials available, let the user log in.\\r\\n if not creds or not creds.valid:\\r\\n if creds and creds.expired and creds.refresh_token:\\r\\n creds.refresh(Request())\\r\\n else:\\r\\n flow = InstalledAppFlow.from_client_secrets_file(\\r\\n 'client_secret.json', SCOPES)\\r\\n creds = flow.run_local_server()\\r\\n # Save the credentials for the next run\\r\\n with open('token.pickle', 'wb') as token:\\r\\n pickle.dump(creds, token)\\r\\n return creds\",\n \"def get_stored_credentials(user):\\n with open(\\\"access.json\\\", \\\"r\\\") as f:\\n credentials = json.load(f)\\n user_creds = credentials[user]\\n return user_creds[\\\"access_token\\\"], user_creds[\\\"access_secret\\\"]\",\n \"def get_credentials(scopes=None, secrets=None, storage=None, *,\\n no_webserver=False):\\n scopes = Scopes.get(scopes)\\n\\n if secrets is None:\\n secrets = SECRETS\\n if storage is None:\\n storage = STORAGE\\n\\n secrets, storage = map(os.path.expanduser, (secrets, storage))\\n\\n store = file.Storage(storage)\\n creds = store.get()\\n\\n if creds is None or creds.invalid:\\n flow = client.flow_from_clientsecrets(secrets, scopes)\\n args = ['--noauth_local_webserver'] if no_webserver else []\\n flags = tools.argparser.parse_args(args)\\n creds = tools.run_flow(flow, store, flags)\\n\\n return creds\",\n \"def valid_credentials():\\n if 'credentials' not in flask.session:\\n return None\\n\\n credentials = client.OAuth2Credentials.from_json(\\n flask.session['credentials'])\\n\\n if (credentials.invalid or credentials.access_token_expired):\\n return None\\n return credentials\",\n \"def get_credentials(client_secrets='client_secrets.json',\\n scope_='https://www.googleapis.com/auth/drive',\\n redirect_uri_='http://localhost:8080'):\\n flow = client.flow_from_clientsecrets(client_secrets,\\n scope=scope_,\\n redirect_uri=redirect_uri_)\\n credentials = tools.run_flow(flow, Store(), None)\\n return credentials\",\n \"def get_credentials(account):\\n credential_dir = os.path.join(HOME_DIR, META_DIR, account, \\\"credentials\\\")\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir, 'pyDrive.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_creds(\\n user=\\\"default\\\", config=None, scope=default_scope, creds_dir=None, save=True\\n):\\n config = config or get_config()\\n try:\\n if \\\"private_key_id\\\" in config:\\n return SACredentials.from_service_account_info(config, scopes=scope)\\n\\n if not isinstance(user, str):\\n raise ConfigException(\\n \\\"Need to provide a user key as a string if not using a service account\\\"\\n )\\n\\n if creds_dir is None:\\n creds_dir = get_config_dir() / \\\"creds\\\"\\n\\n creds_file = Path(creds_dir) / user\\n\\n if creds_file.exists():\\n # need to convert Path to string for python 2.7\\n return OAuthCredentials.from_authorized_user_file(str(creds_file))\\n\\n flow = InstalledAppFlow.from_client_config(config, scope)\\n creds = flow.run_local_server(\\n host=\\\"localhost\\\",\\n port=8182,\\n authorization_prompt_message=\\\"Please visit this URL: {url}\\\",\\n success_message=\\\"The auth flow is complete; you may close this window.\\\",\\n open_browser=False,\\n )\\n\\n if save:\\n creds_data = {\\n \\\"refresh_token\\\": creds.refresh_token,\\n \\\"token_uri\\\": creds.token_uri,\\n \\\"client_id\\\": creds.client_id,\\n \\\"client_secret\\\": creds.client_secret,\\n \\\"scopes\\\": creds.scopes,\\n }\\n\\n ensure_path(creds_dir)\\n creds_file.write_text(decode(json.dumps(creds_data)))\\n\\n return creds\\n except Exception:\\n exc_info = sys.exc_info()\\n raise ConfigException(*exc_info[1:])\",\n \"def get_credentials():\\n #home_dir = os.path.expanduser('~')\\n home_dir = (HOME_DIR)\\n credential_dir = os.path.join(home_dir, '.credentials')\\n print(\\\"Credentials folder: \\\",credential_dir)\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'sheets.googleapis.com-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def GetCredentials(self, credentials_path: str,\\n client_secrets_path: str) -> Optional[Any]:\\n scopes = ['openid', 'https://www.googleapis.com/auth/userinfo.email']\\n credentials = None\\n\\n # Load credentials file if it exists\\n if os.path.exists(credentials_path):\\n try:\\n credentials = Credentials.from_authorized_user_file(\\n credentials_path, scopes)\\n except ValueError as exception:\\n msg = f'Error loading credentials: {exception!s}'\\n self.ModuleError(msg, critical=True)\\n # Refresh credentials using existing refresh_token\\n if credentials and credentials.refresh_token:\\n self.logger.debug('Found a refresh token. Requesting new id_token...')\\n try:\\n credentials.refresh(Request())\\n except google_exceptions.RefreshError as exception:\\n self.logger.debug(f'Error refreshing credentials: {exception!s}')\\n else:\\n # No credentials file, acquire new credentials from secrets file.\\n self.logger.debug(\\n 'Could not find existing credentials. Requesting new tokens.')\\n try:\\n appflow = flow.InstalledAppFlow.from_client_secrets_file(\\n client_secrets_path, scopes)\\n except FileNotFoundError as exception:\\n msg = f'Client secrets file not found: {exception!s}'\\n self.ModuleError(msg, critical=True)\\n\\n self.logger.info(\\n 'Starting local HTTP server on localhost:8888 for OAUTH flow. '\\n 'If running dftimewolf remotely over SSH you will need to tunnel '\\n 'port 8888.')\\n appflow.run_local_server(host='localhost', port=8888, open_browser=False)\\n credentials = appflow.credentials\\n\\n # Save credentials\\n if credentials:\\n with open(credentials_path, 'w', encoding='utf-8') as token:\\n token.write(credentials.to_json())\\n\\n return credentials\",\n \"def get_credentials(commandline_flags=None):\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'drive-python-quickstart.json')\\n\\n store = oauth2client.file.Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if commandline_flags:\\n credentials = tools.run_flow(flow, store, commandline_flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get_credentials():\\n credential_dir = os.path.dirname(os.path.realpath(CLIENT_SECRET_FILE))\\n credential_path = os.path.join(\\n credential_dir, 'sheets.googleapis.com-endosys-events.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def acquire_oauth2_credentials():\\n if os.path.isfile(\\\"%s/cre.json\\\" % file_path):\\n f = open(\\\"%s/cre.json\\\" % file_path, \\\"r\\\")\\n credentials = client.OAuth2Credentials.from_json(f.read())\\n f.close()\\n else: \\n flow = client.flow_from_clientsecrets(\\n \\\"%s/client_secrets.json\\\" % file_path,\\n scope='https://www.googleapis.com/auth/analytics.readonly',\\n redirect_uri='urn:ietf:wg:oauth:2.0:oob')\\n auth_uri = flow.step1_get_authorize_url()\\n webbrowser.open(auth_uri)\\n auth_code = input('Enter the authentication code: ')\\n credentials = flow.step2_exchange(auth_code)\\n write_credentials(\\\"%s/cre.json\\\" % file_path, credentials)\\n return credentials\",\n \"def google_creds() -> object:\\n # If modifying these scopes, delete the file token.pickle.\\n SCOPES = ['https://www.googleapis.com/auth/drive.file',\\n 'https://www.googleapis.com/auth/drive',\\n 'https://www.googleapis.com/auth/drive.activity',\\n 'https://www.googleapis.com/auth/spreadsheets'\\n ]\\n\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n return creds\",\n \"def get_credentials(args, my_dirname):\\n\\n credential_dir = os.path.join(my_dirname, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.mkdir(credential_dir)\\n credential_path = os.path.join(credential_dir, 'sheets.googleapis.com-cotus-checker.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n try:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n credentials = tools.run_flow(flow, store, args)\\n print('Storing credentials to ' + credential_path)\\n except (oauth2client.clientsecrets.InvalidClientSecretsError, json.decoder.JSONDecodeError):\\n pass\\n return credentials\",\n \"def get_GoogleCredentials():\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'calendar-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def _get_credential(self):\\n creds = None\\n\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', self.config['SCOPES'])\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n self.service = build('drive', 'v3', credentials=creds)\",\n \"def get_credentials( flags=None ):\\n home_dir = os.path.expanduser('~')\\n credential_dir = os.path.join(home_dir, '.credentials')\\n if not os.path.exists(credential_dir):\\n os.makedirs(credential_dir)\\n credential_path = os.path.join(credential_dir,\\n 'drive-python-quickstart.json')\\n\\n store = Storage(credential_path)\\n credentials = store.get()\\n if not credentials or credentials.invalid:\\n flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)\\n flow.user_agent = APPLICATION_NAME\\n if flags:\\n credentials = tools.run_flow(flow, store, flags)\\n else: # Needed only for compatibility with Python 2.6\\n credentials = tools.run(flow, store)\\n print('Storing credentials to ' + credential_path)\\n return credentials\",\n \"def get(self):\\n self._lock.acquire()\\n try:\\n f = open(self._filename, 'r')\\n credentials = pickle.loads(f.read())\\n f.close()\\n credentials.set_store(self.put)\\n except:\\n credentials = None\\n self._lock.release()\\n\\n return credentials\",\n \"def get_creds(\\n config: Config=default):\\n config_path = config.credential_path\\n scopes = config.scopes\\n\\n logger.info('loading token')\\n logger.debug(f'config_path: {config_path}')\\n config_path = Path(config_path).expanduser()\\n store = file.Storage(config_path/'token.json')\\n creds = store.get()\\n\\n if not creds or creds.invalid:\\n # Ask the user to give the correct permissions.\\n logger.info('loading credentials')\\n flow = client.flow_from_clientsecrets(\\n config_path/'client_id.json',\\n scopes)\\n\\n arguments = sys.argv\\n sys.argv = sys.argv[0:1]\\n # This line is why we need to remove the arguments from sys.argv\\n # If you find a better way to get it to work, i'm buying it\\n creds = tools.run_flow(flow, store)\\n sys.argv = arguments\\n\\n return creds\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7571535","0.7355913","0.71540344","0.7120326","0.70709026","0.7026004","0.6991126","0.69621813","0.6947445","0.69403243","0.69352114","0.69063586","0.68998873","0.6899442","0.6857314","0.6828924","0.679187","0.6784848","0.677493","0.677493","0.677493","0.677493","0.677493","0.67747265","0.6754786","0.6751389","0.6751389","0.674204","0.6737328","0.6733109","0.6701236","0.6698989","0.66894764","0.66889495","0.66650265","0.665937","0.6644744","0.663259","0.66085875","0.6597621","0.6593084","0.6593084","0.657193","0.6568426","0.6568426","0.65634143","0.65591234","0.6555963","0.6552952","0.6552952","0.6552952","0.6552952","0.65456384","0.65374225","0.6518551","0.65169364","0.65113527","0.65113527","0.64883894","0.6483137","0.64738786","0.6471503","0.6469502","0.6469502","0.6469502","0.6469502","0.6453942","0.64475906","0.6436036","0.64341974","0.6414613","0.64084315","0.6384344","0.6363953","0.6363953","0.63607424","0.6359486","0.6350139","0.63436556","0.63170946","0.6315568","0.62905675","0.6286717","0.6286248","0.6276629","0.62747765","0.6270993","0.62495416","0.6240384","0.6205967","0.6167278","0.6146014","0.6084013","0.6081801","0.60573334","0.6049971","0.60343724","0.603422","0.6005438","0.5944508"],"string":"[\n \"0.7571535\",\n \"0.7355913\",\n \"0.71540344\",\n \"0.7120326\",\n \"0.70709026\",\n \"0.7026004\",\n \"0.6991126\",\n \"0.69621813\",\n \"0.6947445\",\n \"0.69403243\",\n \"0.69352114\",\n \"0.69063586\",\n \"0.68998873\",\n \"0.6899442\",\n \"0.6857314\",\n \"0.6828924\",\n \"0.679187\",\n \"0.6784848\",\n \"0.677493\",\n \"0.677493\",\n \"0.677493\",\n \"0.677493\",\n \"0.677493\",\n \"0.67747265\",\n \"0.6754786\",\n \"0.6751389\",\n \"0.6751389\",\n \"0.674204\",\n \"0.6737328\",\n \"0.6733109\",\n \"0.6701236\",\n \"0.6698989\",\n \"0.66894764\",\n \"0.66889495\",\n \"0.66650265\",\n \"0.665937\",\n \"0.6644744\",\n \"0.663259\",\n \"0.66085875\",\n \"0.6597621\",\n \"0.6593084\",\n \"0.6593084\",\n \"0.657193\",\n \"0.6568426\",\n \"0.6568426\",\n \"0.65634143\",\n \"0.65591234\",\n \"0.6555963\",\n \"0.6552952\",\n \"0.6552952\",\n \"0.6552952\",\n \"0.6552952\",\n \"0.65456384\",\n \"0.65374225\",\n \"0.6518551\",\n \"0.65169364\",\n \"0.65113527\",\n \"0.65113527\",\n \"0.64883894\",\n \"0.6483137\",\n \"0.64738786\",\n \"0.6471503\",\n \"0.6469502\",\n \"0.6469502\",\n \"0.6469502\",\n \"0.6469502\",\n \"0.6453942\",\n \"0.64475906\",\n \"0.6436036\",\n \"0.64341974\",\n \"0.6414613\",\n \"0.64084315\",\n \"0.6384344\",\n \"0.6363953\",\n \"0.6363953\",\n \"0.63607424\",\n \"0.6359486\",\n \"0.6350139\",\n \"0.63436556\",\n \"0.63170946\",\n \"0.6315568\",\n \"0.62905675\",\n \"0.6286717\",\n \"0.6286248\",\n \"0.6276629\",\n \"0.62747765\",\n \"0.6270993\",\n \"0.62495416\",\n \"0.6240384\",\n \"0.6205967\",\n \"0.6167278\",\n \"0.6146014\",\n \"0.6084013\",\n \"0.6081801\",\n \"0.60573334\",\n \"0.6049971\",\n \"0.60343724\",\n \"0.603422\",\n \"0.6005438\",\n \"0.5944508\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6046647"},"document_rank":{"kind":"string","value":"96"}}},{"rowIdx":9475,"cells":{"query":{"kind":"string","value":"return list of id of unread emails"},"document":{"kind":"string","value":"def get_unread_email_ids(gmail_client):\n response = gmail_client.users().messages().list(userId='me',q='is:unread').execute()\n\n if 'messages' in response: # messages key only exists if there are unread messages\n return [message['id'] for message in response['messages']]\n else:\n print(\"No unread messages...\")\n return [] # still return a list since that's what caller expects"},"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 list_unread_emails(self):\n try:\n query = 'is:unread from:scholaralerts-noreply@google.com'\n page_token = None\n p_emails = []\n while True:\n request = self.service.users().messages().list(userId='me',\n q=query, pageToken=page_token)\n response = request.execute()\n if 'messages' not in response:\n break\n p_emails.extend(response['messages'])\n if 'nextPageToken' not in response:\n break\n page_token = response['nextPageToken']\n return p_emails\n\n except errors.HttpError as error:\n _utils.logger.error(f'An error occurred during unread email retrieval: ${error}')","def get_mail_list(self) -> List[int]:\n response = self.IMAP.select(self.mailconfig.folderInbox)\n if response[0] != \"OK\":\n log.error(\"Error accessing Folder '%s': %s\" % (self.mailconfig.folderInbox, response[1][0].decode()))\n emailcount: int = int(response[1][0])\n if not emailcount > 0:\n return []\n log.info(\"%s email(s) in inbox\" % emailcount)\n\n response = self.IMAP.uid(\"search\", None, \"(ALL)\")\n if response[0] != \"OK\":\n log.error(\"Failed to retrieve mails from inbox: %s\" % response[1][0].decode())\n return []\n # TODO: Raise exception?\n indices: List[bytes] = response[1][0].split()\n return [int(x) for x in indices]","def find_unread(mailbox):\n # Not checking here would make the case where there are messages quicker\n numunseen = findall(rb'\\d+', mailbox.status('Inbox', '(UNSEEN)')[1][0])\n if numunseen == [b'0']:\n return ['There are no unread messages']\n\n mailbox.select('inbox')\n res, data = mailbox.search(None, 'UNSEEN')\n if res != 'OK':\n raise RuntimeError('error in search call')\n unseen = data[0].split()\n unseen.reverse()\n messagecount = user.capitalize() + ' : {} new messages'.format(len(unseen))\n meslist = [get_from_subject(mesid, mailbox).strip() for mesid in unseen]\n return [messagecount] + meslist","def util_unread(self):\n try:\n query = 'from:scholaralerts-noreply@google.com'\n page_token = None\n p_emails = []\n while True:\n request = self.service.users().messages().list(userId='me',\n q=query, pageToken=page_token)\n response = request.execute()\n if 'messages' not in response:\n break\n p_emails.extend(response['messages'])\n if 'nextPageToken' not in response:\n break\n page_token = response['nextPageToken']\n self.service.users().messages().batchModify(userId='me', body={\n 'addLabelIds': ['UNREAD'],\n 'ids': [e['id'] for e in p_emails]\n }).execute()\n\n except errors.HttpError as error:\n _utils.logger.error(f'An error occurred: ${error}')","def get_unread_email_data(gmail_client):\n unread_ids = get_unread_email_ids(gmail_client)\n\n for message_id in unread_ids:\n remove_unread_label = {'removeLabelIds': ['UNREAD']}\n gmail_client.users().messages().modify(userId='me', id=message_id, body=remove_unread_label).execute()\n\n message_data = gmail_client.users().messages().get(userId='me',id=message_id).execute()\n message_payload = message_data['payload']\n has_attachment = 0 < len([part for part in message_payload['parts'] if part['mimeType'] == 'image/jpeg'])\n \n message_headers = message_payload['headers']\n sender = [header['value'] for header in message_headers if header['name'] == 'Return-Path'][0]\n yield sender, has_attachment","def _get_unread_emails(conn):\n pattern = re.compile('^\\d+\\ \\(ENVELOPE\\ \\(\"(.*?)\"\\ \"(.*?)\"\\ \\(\\(\"(.*?)\"\\ .*?\\ \"(.*?)\"\\ \"(.*?)\"\\)\\).*$')","def get_unread_messages():\n mark_seen = request.args.get('mark_seen', True)\n unread_msg = g.driver.get_unread()\n\n if mark_seen:\n for msg in unread_msg:\n msg.chat.send_seen()\n\n return jsonify(unread_msg)","def get_unread_count(username, password):\n obj = imaplib.IMAP4_SSL('imap.gmail.com', '993')\n obj.login(username, password)\n obj.select('Inbox')\n message_ids = obj.search(None, \"UNSEEN\")[1]\n list_of_split_strings = str(message_ids).split(\" \")\n unread = len(list_of_split_strings)\n # speak(str(unread))\n return unread","def get_email_ids(conn, query='ALL'):\n if conn.state != \"SELECTED\":\n raise imaplib.IMAP4.error(\"Cannot search without selecting a folder\")\n\n rv, data = conn.uid('search', None, query)\n if rv != 'OK':\n print (\"Could not fetch email ids\") # for some reason...\n return []\n\n return data[0].split()","def get_unread_indexes(self):\n for message in self.messages:\n if message[0] == False:\n return message","def filter_unread(check_what, criteria, return_what):\n imap = imaplib.IMAP4_SSL(config[\"email\"][\"server\"])\n imap.login(config[\"email\"][\"user\"], config[\"email\"][\"pass\"])\n status, messages = imap.select(\"INBOX\")\n \n status, response = imap.search(None, '(UNSEEN)')\n unread_msg_nums = response[0].split()\n\n ret = [] \n for i in unread_msg_nums:\n parse_return = parse(imap, i, check_what, criteria, return_what)\n if parse_return is not None:\n ret.append(parse_return)\n set_unseen(imap, i)\n imap.close()\n imap.logout()\n\n return ret","def get_unread_messages(self):\n self.chat.click()\n loaded_messages = self.__get_loaded_messages()\n for message in loaded_messages:\n try:\n if message.get_attribute(\"class\") == \"XFAMv focusable-list-item\":\n unread_index = loaded_messages.index(message)\n return loaded_messages[unread_index + 1:]\n except:\n continue\n return []","def Get_Unread_Messages(service, userId):\n message_list = []\n message_ids = service.users().messages().list(userId=userId, labelIds='INBOX', alt=\"json\", q='is:unread has:attachment').execute()\n \n if message_ids['resultSizeEstimate'] > 0:\n for message in message_ids['messages']:\n message_list.append(message['id'])\n\n return message_list","def get_unread_count(imap):\n status, messages = imap.select('Inbox')\n status, response = imap.uid('search', None, 'UNSEEN')\n unread_msg_nums = response[0].split()\n return len(unread_msg_nums)","def unread(self):\n return self.filter(unread=True)","def get_new_mails(self):\n\t\tif cint(self.settings.use_imap):\n\t\t\tself.imap.select(\"Inbox\")\n\t\t\tif self.settings.no_remaining == '0' and self.settings.uidnext:\n\t\t\t\tif self.settings.uidnext == self.settings.newuidnext:\n\t\t\t\t\treturn False\n\t\t\t\telse:\n\t\t\t\t\t#request all messages between last uidnext and new\n\t\t\t\t\treturn True\n\t\t\telse:\n\t\t\t\tresponse, message = self.imap.uid('search', None, \"ALL\")\n\t\t\temail_list = message[0].split()\n\t\telse:\n\t\t\temail_list = self.pop.list()[1]\n\n\t\treturn email_list","def get_unread_indexes(self):\n pass","def get_email_ids(self):\n if self.emails is None or self.emails == '':\n return []\n email_ids = self.emails.replace(' ', '')\n return email_ids.split(',')","def list_emails_ids(self, *criteria, mailbox=None) -> List[str]:\n ids = self.get_raw_emails_ids(*criteria, mailbox=mailbox)\n if ids is None:\n raise Exception(f'Cannot get the list of email in the mailbox {self._selected_mailbox}! No list of IDs is returned!')\n return self._search(ids)\n # ListEmailIds.reset()\n # ListEmailIds.parse(ids[0].decode())\n # return ListEmailIds.get_tokens_values()","def filter_seen_messages(self, messages):\n seen_uids = set()\n for uid in messages:\n key = \"%s_%s_%s\" % (self.opt_pop3_server,\n self.opt_global_account[\"username\"], uid.split()[1])\n if self.helper.get_check_point(key) is not None:\n seen_uids.add(uid)\n new_uids = set(messages) - seen_uids\n self.helper.log_debug(\n 'filter_seen_messages: uids on pop3 %s' %\n set(messages))\n self.helper.log_debug(\n 'filter_seen_messages: uids in checkp %s' %\n seen_uids)\n self.helper.log_debug(\n 'filter_seen_messages: uids new %s' %\n new_uids)\n return new_uids","def get_mailbox_uidls(mailbox):\r\n\r\n mbxfile = \"%s\\\\%s.mbx\" % (mailboxdir, mailbox)\r\n\r\n print \"Opening mbx: [%s]\" % mbxfile\r\n\r\n if not os.path.exists(mbxfile):\r\n return []\r\n\r\n fd = open(mbxfile)\r\n\r\n uidls=[]\r\n\r\n for line in fd.readlines():\r\n if line[0:7] == \"* UIDL:\":\r\n list = line.split(':')\r\n uidls.append( list[1].strip() )\r\n\r\n fd.close()\r\n\r\n return uidls\r\n\r\n \"\"\"This function returns a list of all of the uidl (unique id's) of\r\n all of the messages on the server \"\"\"","def email_list(self) -> Sequence[str]:\n return pulumi.get(self, \"email_list\")","def get_all_received_unread_messages(receiver_status):\n unread_message = [\n message for message in user_messages\n if message[\"receiver_status\"] == \"unread\"\n ]\n return unread_message","def unread_count(self) -> dict[str, int]:\n return self.subreddit._reddit.get(API_PATH[\"modmail_unread_count\"])","def get_emails(self):\n email_ids = self.get_email_ids()\n Email = get_email_class()\n return [email for email in Email.objects.filter(pk__in=email_ids)]","def unseen_messages(self, mailbox):\n data = self._cmd(\n \"STATUS\", self._encode_mbox_name(mailbox), \"(UNSEEN)\")\n m = self.unseen_pattern.match(data[-1].decode())\n if m is None:\n return 0\n return int(m.group(1))","def message_nums(request):\n if request.user.is_authenticated:\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\n else:\n return {}","def get_ids(self):\n return self.redis.hkeys(self.feed_items)","def get_raw_emails_ids(self, *criteria, mailbox=None) -> Union[List[bytes], None]:\n self._authenticated_or_die()\n if mailbox is not None:\n self.select_mailbox(mailbox)\n if self._selected_mailbox is None:\n raise Exception('In order to get the list of emails in a mailbox, you must select a mailbox first!')\n criteria = ['ALL'] if 0 == len(criteria) else criteria\n # noinspection PyUnusedLocal\n status: str\n status, ids = self._imap.search(None, *criteria)\n if 'OK' != status:\n return None\n return ids","def get_new_messages(self):\n inbox = list(self.reddit.inbox.unread(limit=10))\n inbox.reverse()\n return inbox","def getIds(self) -> List[int]:\n return list(self.users.keys())","def get_unsent_messages():\n unsent_messages = Message.query.filter(Message.sent == False).all()\n\n # SELECT message_id FROM messages WHERE sent = False\n return unsent_messages","def get_unread(temboo_account, temboo_app, temboo_key, temboo_credentials):\n\tsession = TembooSession(temboo_account, temboo_app, temboo_key)\n\tchoreo = InboxFeed(session)\n\tinputs = choreo.new_input_set()\n\tinputs.set_credential(temboo_credentials)\n\tinputs.set_ResponseFormat('json')\n\tresult = choreo.execute_with_results(inputs)\n\treturn result.get_Response()","def read_modified_alert_ids():\n # Return an empty list if the file doesn't exist.\n if not os.path.exists(MODIFIED_ALERTS_FILE):\n return []\n # Get a lock on the file\n lock = filelock.FileLock(MODIFIED_ALERTS_FILE, 5)\n lock.acquire()\n # Open the file and read in the data.\n fp = open(MODIFIED_ALERTS_FILE, \"r+\")\n ids = fp.read().split(\"\\n\")\n # remove zero length strings\n ids = filter(len, ids)\n # convert IDs to int\n ids = list(map(int, ids))\n # remove duplicates\n ids = list(set(ids))\n # close and remove the file\n fp.close()\n #TODO: uncomment when live\n #os.unlink(MODIFIED_ALERTS_FILE)\n # Release the lock.\n lock.release()\n return ids","def get_user_messages(user_id):\n pass \n # user_message_list = []\n\n # for message in sent messages:","def update_moderator_ids():\n moderator_emails_config = Registry.get_config_property(\n 'moderator_emails')\n if not moderator_emails_config:\n return []\n\n moderator_ids = []\n for email in moderator_emails_config.value:\n user_id = user_services.get_user_id_from_email(email)\n if user_id is not None:\n moderator_ids.append(user_id)\n else:\n raise Exception('Bad moderator email: %s' % email)\n return moderator_ids","def get_referral_emails(self):\n profiles = self.profiles.filter(should_get_notifications=True)\n return [profile.user.email for profile in profiles]","def get_ids(self) -> List[str]:","def list_user_emails(auth0_ids):\n\n list(map(_verify_auth0_id, auth0_ids))\n token = auth0_token()\n config = current_app.config\n emails = _get_all_emails(token=token, config=config)\n return {aid: emails.get(aid, 'Unable to retrieve') for aid in auth0_ids}","def __get_emails(self):\n # This returns a list of Gmail message objects. Documentation can be found at\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\n return self.__service.users().messages().list(userId='me').execute()['messages']","def list_drafts_ids(request):\n if \"drafts\" not in request.session:\n request.session[\"drafts\"] = []\n\n drafts = request.session[\"drafts\"]\n return [draft[\"id\"] for draft in drafts]","def list_active_emails():\n db_customers = Customers.select().where(Customers.status)\n LOGGER.debug(\"Returning list of active customer emails\")\n email_list = [x.email_address for x in db_customers]\n LOGGER.info(\"Email list: %s\", email_list)\n return email_list","def fetch_all(self):\n emails = []\n res, messages = self._mailconn.search(None, 'ALL')\n if res == 'OK':\n for msg in messages[0].split():\n try:\n res, data = self._mailconn.fetch(msg.decode('utf-8'), '(RFC822)')\n except Exception as error:\n self.close_mail_connection()\n print('No email to read: '+error)\n exit()\n \n msg = email.message_from_string((data[0][1]).decode('utf-8'))\n if not isinstance(msg, str):\n if self.is_sender_in_whitelist(msg['From']):\n emails.append(msg)\n\n return emails","def get_messages(self):\n\t\tif not self.check_mails():\n\t\t\treturn # nothing to do\n\n\t\tfrappe.db.commit()\n\n\t\ttry:\n\t\t\t# track if errors arised\n\t\t\tself.errors = False\n\t\t\tself.latest_messages = []\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\tuid_validity = self.get_status()\n\t\t\telse:\n\t\t\t\temail_list = self.get_new_mails()\n\n\n\t\t\t# size limits\n\t\t\tself.total_size = 0\n\t\t\tself.max_email_size = cint(frappe.local.conf.get(\"max_email_size\"))\n\t\t\tself.max_total_size = 5 * self.max_email_size\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\t#try:\n\t\t\t\tif self.check_uid_validity(uid_validity):\n\t\t\t\t\temail_list = self.get_new_mails()\n\t\t\t\t\tif email_list:\n\t\t\t\t\t\tself.get_imap_messages(email_list)\n\t\t\t\t\tself.sync_flags()\n\t\t\t\t\tself.get_seen()\n\t\t\t\t\tself.push_deleted()\n\n\t\t\t\telse:\n\t\t\t\t\tpass\n\n\t\t\telse:\n\t\t\t\tnum = num_copy = len(email_list)\n\n\t\t\t\t# WARNING: Hard coded max no. of messages to be popped\n\t\t\t\tif num > 20: num = 20 #20\n\n\t\t\t\tfor i, message_meta in enumerate(email_list):\n\t\t\t\t\t# do not pull more than NUM emails\n\t\t\t\t\tif (i+1) > num:\n\t\t\t\t\t\tbreak\n\n\t\t\t\t\ttry:\n\t\t\t\t\t\tself.retrieve_message(message_meta, i+1)\n\t\t\t\t\texcept (TotalSizeExceededError, EmailTimeoutError, LoginLimitExceeded):\n\t\t\t\t\t\tbreak\n\n\t\t\t\t# WARNING: Mark as read - message number 101 onwards from the pop list\n\t\t\t\t# This is to avoid having too many messages entering the system\n\t\t\t\tnum = num_copy\n\t\t\t\tif not cint(self.settings.use_imap):\n\t\t\t\t\tif num > 100 and not self.errors:\n\t\t\t\t\t\tfor m in xrange(101, num+1):\n\t\t\t\t\t\t\tself.pop.dele(m)\n\n\t\texcept Exception, e:\n\t\t\tif self.has_login_limit_exceeded(e):\n\t\t\t\tpass\n\n\t\t\telse:\n\t\t\t\traise\n\n\t\tfinally:\n\t\t\t# no matter the exception, pop should quit if connected\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\tself.imap.logout()\n\t\t\telse:\n\t\t\t\tself.pop.quit()\n\n\t\treturn self.latest_messages","def getNotificationsReceived(self):\n return self._delegate.notificationsRecvd","def inbox_count_for(user):\n return Message.inbox.for_user(user).unread().count()","def user_ids(self):\n return list(self.get_users())","def getEventIds(self):\n eventIdsLst = []\n for event in self.eventsLst:\n eventIdsLst.append(event['id'])\n return eventIdsLst","def check_for_subscribers(mail, login_info):\n ADDRESS, PASSWORD = login_info\n\n try:\n mail.select('inbox')\n data = mail.search(None, 'ALL') \n except:\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\n mail.login(ADDRESS, PASSWORD)\n mail.select('inbox')\n data = mail.search(None, 'ALL')\n \n mail_ids = data[1]\n id_list = mail_ids[0].split() \n\n if not id_list:\n return []\n\n first_email_id = int(id_list[0])\n latest_email_id = int(id_list[-1])\n\n subscribers = []\n\n for i in range(latest_email_id, first_email_id-1, -1):\n data = mail.fetch(str(i), '(RFC822)')\n for response_part in data:\n arr = response_part[0]\n if isinstance(arr, tuple):\n msg = email.message_from_string(str(arr[1],'utf-8'))\n email_from = msg['from']\n subscribers.append(email_from)\n\n return subscribers","def user_ids(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"user_ids\")","def emails(self):\r\n return UserEmails(self)","def get_incident_ids() -> list:\n incidents = demisto.get(demisto.context(), \"EmailCampaign.incidents\")\n return [incident['id'] for incident in incidents]","def user_ids(self):\n return list(self._user_ids)","def get_mailing_list():\n\t\tresult = {}\n\t\tconnection = DbHelper.connect()\n\n\t\twith connection.cursor() as cursor:\n\t\t\tsql = \"SELECT email FROM mail_list \\\n\t\t\t\t WHERE is_activated=1;\"\n\t\t\tcursor.execute(sql)\n\t\t\tresult = cursor.fetchall()\n\n\t\treturn [email_data['email'] for email_data in result]","def get_users_for(self, email):\r\n # this is a list rather than a generator because we probably want to do a len() on it right away\r\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]","def update_admin_ids():\n admin_emails_config = Registry.get_config_property(\n 'admin_emails')\n if not admin_emails_config:\n return []\n\n admin_ids = []\n for email in admin_emails_config.value:\n user_id = user_services.get_user_id_from_email(email)\n if user_id is not None:\n admin_ids.append(user_id)\n else:\n raise Exception('Bad admin email: %s' % email)\n return admin_ids","def get_read_by(self):\n return {entry.username for entry in self.history if entry.action == MessageAction.read}","def get_message_users(message_id):\n if UserMessage.message_id:\n return UserMessage.query.filter(message_id == UserMessage.message_id).all()\n else:\n return \"This message has not been sent to anybody\"","def email_all():\n\tSubscribtion = session.query(email).all()\n\treturn subscribtion_object","def get_messages(chat_id):\n\n mark_seen = request.args.get('mark_seen', True)\n\n chat = g.driver.get_chat_from_id(chat_id)\n msgs = list(g.driver.get_all_messages_in_chat(chat))\n\n for msg in msgs:\n print(msg.id)\n\n if mark_seen:\n for msg in msgs:\n try:\n msg.chat.send_seen()\n except:\n pass\n \n return jsonify(msgs)","def fetchmail(self):\n mails = []\n\n if self.security == 'SSL/TLS':\n imap = IMAP4_SSL(self.host, self.port)\n else:\n imap = IMAP4(self.host, self.port)\n if self.security == 'STARTTLS':\n imap.starttls()\n imap.login(self.username, self.passwd)\n imap.select(readonly=True)\n\n status, uids = imap.uid('SEARCH', 'UNSEEN')\n\n for uid in uids[0].split():\n status, data = imap.uid('FETCH', uid, '(BODY[HEADER.FIELDS (DATE SUBJECT FROM)])')\n message = self._message_from_data(data)\n mail = Mail(uid, message['FROM'], message['SUBJECT'], message['DATE'])\n mails.append(mail)\n\n imap.close()\n imap.logout()\n\n return mails","def check_user_email(self, email):\n useremails = []\n for user in self.__users:\n if user['email'] == email:\n useremails.append(user)\n return useremails","def getIDs():","def readMail(m, msgNum):#Read a particular email\n resp, data = m.fetch(msgNum, \"(RFC822)\")\n email_body = data[0][1]\n mail = email.message_from_string(email_body)\n #temp = m.store(emailid,'+FLAGS', '\\\\Seen')\n m.expunge()\n\n\n return mail","def getAssignedUsers(id=0):\n a = [x.user_ID for x in Assignment.query.filter(Assignment.countEvent_ID == id) ]\n return a","def get_public_messages(self):\n messages = []\n for message in self.messages:\n if message.message_id != None:\n messages.append(message)\n return messages","def check_gmail(username, password):\n i = imaplib.IMAP4_SSL('imap.gmail.com')\n try:\n i.login(username, password)\n x, y = i.status('INBOX', '(MESSAGES UNSEEN)')\n messages = int(re.search('MESSAGES\\s+(\\d+)', y[0]).group(1))\n unseen = int(re.search('UNSEEN\\s+(\\d+)', y[0]).group(1))\n return messages, unseen\n except:\n return False, 0","def read(self):\n return self.filter(unread=False)","def get_uids():\n DB_NAME = 'cloud_storage.db'\n DB_DIRECTORY = 'server_side_storage/'\n db = sqlite3.connect('{}{}'.format(DB_DIRECTORY, DB_NAME))\n cursor = db.cursor()\n cursor.execute(\"SELECT uid FROM user_ids\")\n all_uids = cursor.fetchall()\n db.commit()\n cursor.close()\n db.close()\n all_uids = list(itertools.chain(*all_uids))\n return all_uids","def _get_exploration_ids_subscribed_to(self, user_id: str) -> List[str]:\n subscriptions_model = user_models.UserSubscriptionsModel.get(\n user_id, strict=False)\n # TODO(#15621): The explicit declaration of type for ndb properties\n # should be removed. Currently, these ndb properties are annotated with\n # Any return type. Once we have proper return type we can remove this.\n if subscriptions_model:\n exploration_ids: List[str] = subscriptions_model.exploration_ids\n return exploration_ids\n else:\n return []","def user_ids(self):\r\n raise NotImplementedError","def search(folderName):\n\n result, data = mailBox.select(folderName, True)\n\n if TESTING:\n searchResult, uid = mailBox.uid('SEARCH', None, 'UNSEEN')\n else:\n searchResult, uid = mailBox.uid('SEARCH', None, 'ALL')\n\n number_messages = len(uid[0].split(' ')) if uid[0] != \"\" else 0\n if number_messages == 0:\n print \"\\nERROR: No messages found in %s\\n\" % folderName\n print \"\\n* Exiting... *\\n\"\n sys.exit(0)\n print \"\\nNumber of messages in %s: %d\" % (folderName, number_messages)\n\n uidList = \"\"\n for i in uid[0].split(' '):\n if i.isdigit():\n uidList += i + \",\"\n uidList = uidList[:-1]\n\n return uidList","def getEmail(self, data):\r\n\t\tprint('test')\r\n\t\t# Empty array to hold unique emails\r\n\t\tno_dp_email = []\r\n\r\n\t\t# Loop through each row in the dataframe...\r\n\t\tfor row in data.itertuples():\r\n\t\t\tprint('test')\r\n\r\n\t\t\t# Parse through the row's keywords string for emails...\r\n\t\t\temails = re.findall(\"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}\", row.keywords)\r\n\t\t\tprint(emails)\r\n\t\t\tprint('test')\r\n\r\n\t\t\t# For each email in the array...\r\n\t\t\tfor email in emails:\r\n\t\t\t\tprint('test')\r\n\r\n\t\t\t\temail = str(email)\r\n\r\n\t\t\t\t# Append this email onto the array if it is not a repeat\r\n\t\t\t\tif email not in no_dp_email:\r\n\t\t\t\t\tprint('test')\r\n\r\n\t\t\t\t\tno_dp_email.append(email)\r\n\t\t\r\n\t\t# return array of unique emails\r\n\t\treturn no_dp_email","def get_message_ids_by_query(query_string, service):\n message_results = service.users().messages().list(userId='me', q=query_string).execute()\n if(message_results['resultSizeEstimate'] == 0):\n return []\n return message_results['messages'] if message_results['messages'] is not None else []","def sender_email_notifications(self):\n return self._sender_email_notifications","def get_ids(self):\n return [item.id for item in self.items]","def mark_all_as_unread(self, recipient=None):\n qs = self.read()\n if recipient:\n qs = qs.filter(recipient=recipient)\n\n return qs.update(unread=True)","def fetch( self, all=0, seen=None, mark=None ):\n conn = self._v_conn\n indx = self._v_indx\n msgs = []\n\n if seen is None:\n seen = self._v_seen\n if seen is None:\n all = 1\n mark = 0\n\n elif mark is None:\n mark = 1\n\n if indx is None:\n try:\n indx = self._getUids()\n except:\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] error getting message index' % ( self._v_login, self.address() ), error=exc_info() )\n raise\n\n #LOG( 'MailServer.fetch', TRACE, 'server has %d message(s)' % len(indx) )\n\n for i, uid in indx:\n if not all and seen.has_key( uid ):\n continue\n\n #LOG( 'MailServer.fetch', TRACE, 'retrieving message %d uid=%s' % (i, uid) )\n\n try:\n res, lines, size = conn.retr( i )\n except:\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] cannot retrieve message %d uid=%s' % ( self._v_login, self.address(), i, uid ), \\\n error=exc_info() )\n continue\n\n try:\n msg = self.createMessage( source=join( lines, '\\n') )\n except:\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] cannot parse message %d uid=%s' % (self._v_login, self.address(), i, uid), \\\n error=exc_info() )\n continue\n\n msg.uid = uid\n msgs.append( msg )\n\n if mark:\n seen[ uid ] = 1\n\n return msgs","def get_append_messages(self):\n\t\treturn self.checkAppendMessages.get_active()","def get_inbox(character):\n messages = get_messages(character)\n return [ Mail(message) for message in messages ]","def find_expired_email(mails):\n if not mails:\n return []\n\n # get a copy of mails sort by datetime in desc order first\n mails_date = sorted(mails, key=lambda m:m.datetime, reverse=True)\n last7mails = mails_date[:7]\n bmail = last7mails[-1]\n # year|month|date => mail.mid\n reserv_mails = { m.datetime:m.mid for m in last7mails }\n def reserv_m(key, mail):\n if not reserv_mails.has_key(key):\n reserv_mails[key] = mail.mid\n\n for mail in mails_date[7:]:\n if mail.datetime.year < bmail.datetime.year:\n # mails sent in the last years, keep the newest mail per year\n reserv_m(mail.datetime.year, mail)\n elif mail.datetime.year == bmail.datetime.year and \\\n mail.datetime.month < bmail.datetime.month:\n # mails sent in the last months, keep the newest mail per month\n reserv_m(mail.datetime.month, mail)\n\n reserv_mids = dict.fromkeys(reserv_mails.values())\n return [m for m in mails if m.mid not in reserv_mids]","def emails(self):\r\n return emails.Emails(self)","def get_emails_in_blacklist(self, limit=0, offset=0):\n logger.info(\"Function call: get_emails_in_blacklist\")\n return self.__handle_result(self.__send_request('blacklist', 'GET', {'limit': limit or 0, 'offset': offset or 0}))","def inbox(self):\n return self._get_messages_from_folder_name('Inbox')","def fetch(self, messages, uid):\n return list(zip(range(1, len(self.msgObjs) + 1), self.msgObjs))","def userAllMessages(self, uid):\n return self.userMessages(self.userMessageBox(self.getUuidFromUid(uid)), \"_?([a-f]|[0-9]){8}-([a-f]|[0-9]){4}-([a-f]|[0-9]){4}-([a-f]|[0-9]){4}-([a-f]|[0-9]){12}_[0-9]+\")","def get_unread_entries(self, mark_read: bool = False) -> dict[str, list[Entry]]:\n with make_reader(self.reader_db_file) as reader:\n unread = reader.get_entries(read=False)\n entries = {}\n for e in unread:\n url = e.feed_url\n if url in entries:\n entries[url].append(e)\n else:\n entries[url] = [e]\n\n if mark_read:\n reader.mark_entry_as_read(e)\n\n return entries","def mark_all_notifications_as_read(self):\n for n in Notification.objects(owner=self, unread=True):\n n.unread = False\n n.save()","def unique_email_count(self):\n return len(set(self.stripped_email_list))","def get_pubmed_ids(self):\n return self.pmids","def get_message_list(self):\n count = 0\n for msg in self.mbox:\n if msg['From'].find(self.config['tgt_email']) > -1:\n dtime = arrow.get(msg['Date'], 'ddd, D MMM YYYY HH:mm:ss ZZ')\n message = dict({'from': msg['From'],\n 'date': dtime,\n 'subject': msg['Subject']})\n # boundary = msg.get_boundary()\n # if boundary is not None:\n # bounds = [m.start() for m\n # in re.finditer(boundary, str(msg))]\n # else:\n # bounds = list()\n # if len(bounds) > 2:\n # message['text'] = str(msg)[bounds[1]:bounds[2]]\n # else:\n # message['text'] = None\n pl = None\n if msg['Subject'].find(\":\") == -1:\n finished = False\n pl = msg.get_payload()\n while finished is False:\n if isinstance(pl, str):\n finished = True\n elif isinstance(pl, list):\n pl = pl[0].get_payload()\n else:\n raise ValueError(\"Non-list, non-str payload?\")\n break\n message['text'] = self.clean_text(str(pl))\n\n if message['text'] is not None:\n self.messages.append(message)\n count += 1\n # print count\n self.messages.sort(key=lambda item: item['date'])","def checkMsgNum(m):\n #mboxes = m.list()[1] Show all boxes\n m.select(\"INBOX\")#Select mailbox\n #data = m.search(None, \"(FROM \\\"default@gmail.com\\\")\") Search specific email addy\n #Change \"default@gmail.com\" in above to a specific email address to enable search from particular user\n items = m.search(None, \"(UNSEEN)\")\n msgNum = str(items[1]).rsplit(None)[-1].strip('[\\']')\n\n return msgNum","def test_alice_unread(self):\n messages = list(self.alice_inbox.unread)\n self.assertEqual(1, len(messages))\n self.assertIn(self.bob_message_to_group1, messages)\n self.assertNotIn(self.read_message, messages)\n self.assertNotIn(self.alice_message_to_bob, messages)\n self.assertNotIn(self.archived_message, messages)","def getUserIds(self):\n raise BorkedGetUserIds","def emails(self):\r\n url = api_base + 'emails/'\r\n return json.loads(self.load_url(url))","def _get_chat_id_list():\n cfg = read_config()\n cfg = cfg['notifier']['telegram_bot']\n return cfg.get('chat_id')","def get_messages(character):\n mail = character.db.mail\n try:\n messages = [item for item in mail if item[TIMESTAMP] <= item[MESSAGE].date_sent]\n # Let's clean up mail storage for this user while we're at it.\n character.db.mail = messages\n except TypeError:\n messages = []\n return messages","def all_users(self):\n distinct_users = list(self.client.smartsleep.attendees.distinct(\"userId\"))\n return distinct_users","def get_user_ids(session, access_token):\n endpoint = \"https://graph.microsoft.com/v1.0/users?$select=id\"\n r = session.get(endpoint, headers={\"Authorization\": \"Bearer \" + access_token})\n response = json.loads(r.text)\n return response[\"value\"]","def list_messages(self):"],"string":"[\n \"def list_unread_emails(self):\\n try:\\n query = 'is:unread from:scholaralerts-noreply@google.com'\\n page_token = None\\n p_emails = []\\n while True:\\n request = self.service.users().messages().list(userId='me',\\n q=query, pageToken=page_token)\\n response = request.execute()\\n if 'messages' not in response:\\n break\\n p_emails.extend(response['messages'])\\n if 'nextPageToken' not in response:\\n break\\n page_token = response['nextPageToken']\\n return p_emails\\n\\n except errors.HttpError as error:\\n _utils.logger.error(f'An error occurred during unread email retrieval: ${error}')\",\n \"def get_mail_list(self) -> List[int]:\\n response = self.IMAP.select(self.mailconfig.folderInbox)\\n if response[0] != \\\"OK\\\":\\n log.error(\\\"Error accessing Folder '%s': %s\\\" % (self.mailconfig.folderInbox, response[1][0].decode()))\\n emailcount: int = int(response[1][0])\\n if not emailcount > 0:\\n return []\\n log.info(\\\"%s email(s) in inbox\\\" % emailcount)\\n\\n response = self.IMAP.uid(\\\"search\\\", None, \\\"(ALL)\\\")\\n if response[0] != \\\"OK\\\":\\n log.error(\\\"Failed to retrieve mails from inbox: %s\\\" % response[1][0].decode())\\n return []\\n # TODO: Raise exception?\\n indices: List[bytes] = response[1][0].split()\\n return [int(x) for x in indices]\",\n \"def find_unread(mailbox):\\n # Not checking here would make the case where there are messages quicker\\n numunseen = findall(rb'\\\\d+', mailbox.status('Inbox', '(UNSEEN)')[1][0])\\n if numunseen == [b'0']:\\n return ['There are no unread messages']\\n\\n mailbox.select('inbox')\\n res, data = mailbox.search(None, 'UNSEEN')\\n if res != 'OK':\\n raise RuntimeError('error in search call')\\n unseen = data[0].split()\\n unseen.reverse()\\n messagecount = user.capitalize() + ' : {} new messages'.format(len(unseen))\\n meslist = [get_from_subject(mesid, mailbox).strip() for mesid in unseen]\\n return [messagecount] + meslist\",\n \"def util_unread(self):\\n try:\\n query = 'from:scholaralerts-noreply@google.com'\\n page_token = None\\n p_emails = []\\n while True:\\n request = self.service.users().messages().list(userId='me',\\n q=query, pageToken=page_token)\\n response = request.execute()\\n if 'messages' not in response:\\n break\\n p_emails.extend(response['messages'])\\n if 'nextPageToken' not in response:\\n break\\n page_token = response['nextPageToken']\\n self.service.users().messages().batchModify(userId='me', body={\\n 'addLabelIds': ['UNREAD'],\\n 'ids': [e['id'] for e in p_emails]\\n }).execute()\\n\\n except errors.HttpError as error:\\n _utils.logger.error(f'An error occurred: ${error}')\",\n \"def get_unread_email_data(gmail_client):\\n unread_ids = get_unread_email_ids(gmail_client)\\n\\n for message_id in unread_ids:\\n remove_unread_label = {'removeLabelIds': ['UNREAD']}\\n gmail_client.users().messages().modify(userId='me', id=message_id, body=remove_unread_label).execute()\\n\\n message_data = gmail_client.users().messages().get(userId='me',id=message_id).execute()\\n message_payload = message_data['payload']\\n has_attachment = 0 < len([part for part in message_payload['parts'] if part['mimeType'] == 'image/jpeg'])\\n \\n message_headers = message_payload['headers']\\n sender = [header['value'] for header in message_headers if header['name'] == 'Return-Path'][0]\\n yield sender, has_attachment\",\n \"def _get_unread_emails(conn):\\n pattern = re.compile('^\\\\d+\\\\ \\\\(ENVELOPE\\\\ \\\\(\\\"(.*?)\\\"\\\\ \\\"(.*?)\\\"\\\\ \\\\(\\\\(\\\"(.*?)\\\"\\\\ .*?\\\\ \\\"(.*?)\\\"\\\\ \\\"(.*?)\\\"\\\\)\\\\).*$')\",\n \"def get_unread_messages():\\n mark_seen = request.args.get('mark_seen', True)\\n unread_msg = g.driver.get_unread()\\n\\n if mark_seen:\\n for msg in unread_msg:\\n msg.chat.send_seen()\\n\\n return jsonify(unread_msg)\",\n \"def get_unread_count(username, password):\\n obj = imaplib.IMAP4_SSL('imap.gmail.com', '993')\\n obj.login(username, password)\\n obj.select('Inbox')\\n message_ids = obj.search(None, \\\"UNSEEN\\\")[1]\\n list_of_split_strings = str(message_ids).split(\\\" \\\")\\n unread = len(list_of_split_strings)\\n # speak(str(unread))\\n return unread\",\n \"def get_email_ids(conn, query='ALL'):\\n if conn.state != \\\"SELECTED\\\":\\n raise imaplib.IMAP4.error(\\\"Cannot search without selecting a folder\\\")\\n\\n rv, data = conn.uid('search', None, query)\\n if rv != 'OK':\\n print (\\\"Could not fetch email ids\\\") # for some reason...\\n return []\\n\\n return data[0].split()\",\n \"def get_unread_indexes(self):\\n for message in self.messages:\\n if message[0] == False:\\n return message\",\n \"def filter_unread(check_what, criteria, return_what):\\n imap = imaplib.IMAP4_SSL(config[\\\"email\\\"][\\\"server\\\"])\\n imap.login(config[\\\"email\\\"][\\\"user\\\"], config[\\\"email\\\"][\\\"pass\\\"])\\n status, messages = imap.select(\\\"INBOX\\\")\\n \\n status, response = imap.search(None, '(UNSEEN)')\\n unread_msg_nums = response[0].split()\\n\\n ret = [] \\n for i in unread_msg_nums:\\n parse_return = parse(imap, i, check_what, criteria, return_what)\\n if parse_return is not None:\\n ret.append(parse_return)\\n set_unseen(imap, i)\\n imap.close()\\n imap.logout()\\n\\n return ret\",\n \"def get_unread_messages(self):\\n self.chat.click()\\n loaded_messages = self.__get_loaded_messages()\\n for message in loaded_messages:\\n try:\\n if message.get_attribute(\\\"class\\\") == \\\"XFAMv focusable-list-item\\\":\\n unread_index = loaded_messages.index(message)\\n return loaded_messages[unread_index + 1:]\\n except:\\n continue\\n return []\",\n \"def Get_Unread_Messages(service, userId):\\n message_list = []\\n message_ids = service.users().messages().list(userId=userId, labelIds='INBOX', alt=\\\"json\\\", q='is:unread has:attachment').execute()\\n \\n if message_ids['resultSizeEstimate'] > 0:\\n for message in message_ids['messages']:\\n message_list.append(message['id'])\\n\\n return message_list\",\n \"def get_unread_count(imap):\\n status, messages = imap.select('Inbox')\\n status, response = imap.uid('search', None, 'UNSEEN')\\n unread_msg_nums = response[0].split()\\n return len(unread_msg_nums)\",\n \"def unread(self):\\n return self.filter(unread=True)\",\n \"def get_new_mails(self):\\n\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\tself.imap.select(\\\"Inbox\\\")\\n\\t\\t\\tif self.settings.no_remaining == '0' and self.settings.uidnext:\\n\\t\\t\\t\\tif self.settings.uidnext == self.settings.newuidnext:\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t#request all messages between last uidnext and new\\n\\t\\t\\t\\t\\treturn True\\n\\t\\t\\telse:\\n\\t\\t\\t\\tresponse, message = self.imap.uid('search', None, \\\"ALL\\\")\\n\\t\\t\\temail_list = message[0].split()\\n\\t\\telse:\\n\\t\\t\\temail_list = self.pop.list()[1]\\n\\n\\t\\treturn email_list\",\n \"def get_unread_indexes(self):\\n pass\",\n \"def get_email_ids(self):\\n if self.emails is None or self.emails == '':\\n return []\\n email_ids = self.emails.replace(' ', '')\\n return email_ids.split(',')\",\n \"def list_emails_ids(self, *criteria, mailbox=None) -> List[str]:\\n ids = self.get_raw_emails_ids(*criteria, mailbox=mailbox)\\n if ids is None:\\n raise Exception(f'Cannot get the list of email in the mailbox {self._selected_mailbox}! No list of IDs is returned!')\\n return self._search(ids)\\n # ListEmailIds.reset()\\n # ListEmailIds.parse(ids[0].decode())\\n # return ListEmailIds.get_tokens_values()\",\n \"def filter_seen_messages(self, messages):\\n seen_uids = set()\\n for uid in messages:\\n key = \\\"%s_%s_%s\\\" % (self.opt_pop3_server,\\n self.opt_global_account[\\\"username\\\"], uid.split()[1])\\n if self.helper.get_check_point(key) is not None:\\n seen_uids.add(uid)\\n new_uids = set(messages) - seen_uids\\n self.helper.log_debug(\\n 'filter_seen_messages: uids on pop3 %s' %\\n set(messages))\\n self.helper.log_debug(\\n 'filter_seen_messages: uids in checkp %s' %\\n seen_uids)\\n self.helper.log_debug(\\n 'filter_seen_messages: uids new %s' %\\n new_uids)\\n return new_uids\",\n \"def get_mailbox_uidls(mailbox):\\r\\n\\r\\n mbxfile = \\\"%s\\\\\\\\%s.mbx\\\" % (mailboxdir, mailbox)\\r\\n\\r\\n print \\\"Opening mbx: [%s]\\\" % mbxfile\\r\\n\\r\\n if not os.path.exists(mbxfile):\\r\\n return []\\r\\n\\r\\n fd = open(mbxfile)\\r\\n\\r\\n uidls=[]\\r\\n\\r\\n for line in fd.readlines():\\r\\n if line[0:7] == \\\"* UIDL:\\\":\\r\\n list = line.split(':')\\r\\n uidls.append( list[1].strip() )\\r\\n\\r\\n fd.close()\\r\\n\\r\\n return uidls\\r\\n\\r\\n \\\"\\\"\\\"This function returns a list of all of the uidl (unique id's) of\\r\\n all of the messages on the server \\\"\\\"\\\"\",\n \"def email_list(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"email_list\\\")\",\n \"def get_all_received_unread_messages(receiver_status):\\n unread_message = [\\n message for message in user_messages\\n if message[\\\"receiver_status\\\"] == \\\"unread\\\"\\n ]\\n return unread_message\",\n \"def unread_count(self) -> dict[str, int]:\\n return self.subreddit._reddit.get(API_PATH[\\\"modmail_unread_count\\\"])\",\n \"def get_emails(self):\\n email_ids = self.get_email_ids()\\n Email = get_email_class()\\n return [email for email in Email.objects.filter(pk__in=email_ids)]\",\n \"def unseen_messages(self, mailbox):\\n data = self._cmd(\\n \\\"STATUS\\\", self._encode_mbox_name(mailbox), \\\"(UNSEEN)\\\")\\n m = self.unseen_pattern.match(data[-1].decode())\\n if m is None:\\n return 0\\n return int(m.group(1))\",\n \"def message_nums(request):\\n if request.user.is_authenticated:\\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\\n else:\\n return {}\",\n \"def get_ids(self):\\n return self.redis.hkeys(self.feed_items)\",\n \"def get_raw_emails_ids(self, *criteria, mailbox=None) -> Union[List[bytes], None]:\\n self._authenticated_or_die()\\n if mailbox is not None:\\n self.select_mailbox(mailbox)\\n if self._selected_mailbox is None:\\n raise Exception('In order to get the list of emails in a mailbox, you must select a mailbox first!')\\n criteria = ['ALL'] if 0 == len(criteria) else criteria\\n # noinspection PyUnusedLocal\\n status: str\\n status, ids = self._imap.search(None, *criteria)\\n if 'OK' != status:\\n return None\\n return ids\",\n \"def get_new_messages(self):\\n inbox = list(self.reddit.inbox.unread(limit=10))\\n inbox.reverse()\\n return inbox\",\n \"def getIds(self) -> List[int]:\\n return list(self.users.keys())\",\n \"def get_unsent_messages():\\n unsent_messages = Message.query.filter(Message.sent == False).all()\\n\\n # SELECT message_id FROM messages WHERE sent = False\\n return unsent_messages\",\n \"def get_unread(temboo_account, temboo_app, temboo_key, temboo_credentials):\\n\\tsession = TembooSession(temboo_account, temboo_app, temboo_key)\\n\\tchoreo = InboxFeed(session)\\n\\tinputs = choreo.new_input_set()\\n\\tinputs.set_credential(temboo_credentials)\\n\\tinputs.set_ResponseFormat('json')\\n\\tresult = choreo.execute_with_results(inputs)\\n\\treturn result.get_Response()\",\n \"def read_modified_alert_ids():\\n # Return an empty list if the file doesn't exist.\\n if not os.path.exists(MODIFIED_ALERTS_FILE):\\n return []\\n # Get a lock on the file\\n lock = filelock.FileLock(MODIFIED_ALERTS_FILE, 5)\\n lock.acquire()\\n # Open the file and read in the data.\\n fp = open(MODIFIED_ALERTS_FILE, \\\"r+\\\")\\n ids = fp.read().split(\\\"\\\\n\\\")\\n # remove zero length strings\\n ids = filter(len, ids)\\n # convert IDs to int\\n ids = list(map(int, ids))\\n # remove duplicates\\n ids = list(set(ids))\\n # close and remove the file\\n fp.close()\\n #TODO: uncomment when live\\n #os.unlink(MODIFIED_ALERTS_FILE)\\n # Release the lock.\\n lock.release()\\n return ids\",\n \"def get_user_messages(user_id):\\n pass \\n # user_message_list = []\\n\\n # for message in sent messages:\",\n \"def update_moderator_ids():\\n moderator_emails_config = Registry.get_config_property(\\n 'moderator_emails')\\n if not moderator_emails_config:\\n return []\\n\\n moderator_ids = []\\n for email in moderator_emails_config.value:\\n user_id = user_services.get_user_id_from_email(email)\\n if user_id is not None:\\n moderator_ids.append(user_id)\\n else:\\n raise Exception('Bad moderator email: %s' % email)\\n return moderator_ids\",\n \"def get_referral_emails(self):\\n profiles = self.profiles.filter(should_get_notifications=True)\\n return [profile.user.email for profile in profiles]\",\n \"def get_ids(self) -> List[str]:\",\n \"def list_user_emails(auth0_ids):\\n\\n list(map(_verify_auth0_id, auth0_ids))\\n token = auth0_token()\\n config = current_app.config\\n emails = _get_all_emails(token=token, config=config)\\n return {aid: emails.get(aid, 'Unable to retrieve') for aid in auth0_ids}\",\n \"def __get_emails(self):\\n # This returns a list of Gmail message objects. Documentation can be found at\\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\\n return self.__service.users().messages().list(userId='me').execute()['messages']\",\n \"def list_drafts_ids(request):\\n if \\\"drafts\\\" not in request.session:\\n request.session[\\\"drafts\\\"] = []\\n\\n drafts = request.session[\\\"drafts\\\"]\\n return [draft[\\\"id\\\"] for draft in drafts]\",\n \"def list_active_emails():\\n db_customers = Customers.select().where(Customers.status)\\n LOGGER.debug(\\\"Returning list of active customer emails\\\")\\n email_list = [x.email_address for x in db_customers]\\n LOGGER.info(\\\"Email list: %s\\\", email_list)\\n return email_list\",\n \"def fetch_all(self):\\n emails = []\\n res, messages = self._mailconn.search(None, 'ALL')\\n if res == 'OK':\\n for msg in messages[0].split():\\n try:\\n res, data = self._mailconn.fetch(msg.decode('utf-8'), '(RFC822)')\\n except Exception as error:\\n self.close_mail_connection()\\n print('No email to read: '+error)\\n exit()\\n \\n msg = email.message_from_string((data[0][1]).decode('utf-8'))\\n if not isinstance(msg, str):\\n if self.is_sender_in_whitelist(msg['From']):\\n emails.append(msg)\\n\\n return emails\",\n \"def get_messages(self):\\n\\t\\tif not self.check_mails():\\n\\t\\t\\treturn # nothing to do\\n\\n\\t\\tfrappe.db.commit()\\n\\n\\t\\ttry:\\n\\t\\t\\t# track if errors arised\\n\\t\\t\\tself.errors = False\\n\\t\\t\\tself.latest_messages = []\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\tuid_validity = self.get_status()\\n\\t\\t\\telse:\\n\\t\\t\\t\\temail_list = self.get_new_mails()\\n\\n\\n\\t\\t\\t# size limits\\n\\t\\t\\tself.total_size = 0\\n\\t\\t\\tself.max_email_size = cint(frappe.local.conf.get(\\\"max_email_size\\\"))\\n\\t\\t\\tself.max_total_size = 5 * self.max_email_size\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\t#try:\\n\\t\\t\\t\\tif self.check_uid_validity(uid_validity):\\n\\t\\t\\t\\t\\temail_list = self.get_new_mails()\\n\\t\\t\\t\\t\\tif email_list:\\n\\t\\t\\t\\t\\t\\tself.get_imap_messages(email_list)\\n\\t\\t\\t\\t\\tself.sync_flags()\\n\\t\\t\\t\\t\\tself.get_seen()\\n\\t\\t\\t\\t\\tself.push_deleted()\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tpass\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnum = num_copy = len(email_list)\\n\\n\\t\\t\\t\\t# WARNING: Hard coded max no. of messages to be popped\\n\\t\\t\\t\\tif num > 20: num = 20 #20\\n\\n\\t\\t\\t\\tfor i, message_meta in enumerate(email_list):\\n\\t\\t\\t\\t\\t# do not pull more than NUM emails\\n\\t\\t\\t\\t\\tif (i+1) > num:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tself.retrieve_message(message_meta, i+1)\\n\\t\\t\\t\\t\\texcept (TotalSizeExceededError, EmailTimeoutError, LoginLimitExceeded):\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t# WARNING: Mark as read - message number 101 onwards from the pop list\\n\\t\\t\\t\\t# This is to avoid having too many messages entering the system\\n\\t\\t\\t\\tnum = num_copy\\n\\t\\t\\t\\tif not cint(self.settings.use_imap):\\n\\t\\t\\t\\t\\tif num > 100 and not self.errors:\\n\\t\\t\\t\\t\\t\\tfor m in xrange(101, num+1):\\n\\t\\t\\t\\t\\t\\t\\tself.pop.dele(m)\\n\\n\\t\\texcept Exception, e:\\n\\t\\t\\tif self.has_login_limit_exceeded(e):\\n\\t\\t\\t\\tpass\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise\\n\\n\\t\\tfinally:\\n\\t\\t\\t# no matter the exception, pop should quit if connected\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\tself.imap.logout()\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.pop.quit()\\n\\n\\t\\treturn self.latest_messages\",\n \"def getNotificationsReceived(self):\\n return self._delegate.notificationsRecvd\",\n \"def inbox_count_for(user):\\n return Message.inbox.for_user(user).unread().count()\",\n \"def user_ids(self):\\n return list(self.get_users())\",\n \"def getEventIds(self):\\n eventIdsLst = []\\n for event in self.eventsLst:\\n eventIdsLst.append(event['id'])\\n return eventIdsLst\",\n \"def check_for_subscribers(mail, login_info):\\n ADDRESS, PASSWORD = login_info\\n\\n try:\\n mail.select('inbox')\\n data = mail.search(None, 'ALL') \\n except:\\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\\n mail.login(ADDRESS, PASSWORD)\\n mail.select('inbox')\\n data = mail.search(None, 'ALL')\\n \\n mail_ids = data[1]\\n id_list = mail_ids[0].split() \\n\\n if not id_list:\\n return []\\n\\n first_email_id = int(id_list[0])\\n latest_email_id = int(id_list[-1])\\n\\n subscribers = []\\n\\n for i in range(latest_email_id, first_email_id-1, -1):\\n data = mail.fetch(str(i), '(RFC822)')\\n for response_part in data:\\n arr = response_part[0]\\n if isinstance(arr, tuple):\\n msg = email.message_from_string(str(arr[1],'utf-8'))\\n email_from = msg['from']\\n subscribers.append(email_from)\\n\\n return subscribers\",\n \"def user_ids(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"user_ids\\\")\",\n \"def emails(self):\\r\\n return UserEmails(self)\",\n \"def get_incident_ids() -> list:\\n incidents = demisto.get(demisto.context(), \\\"EmailCampaign.incidents\\\")\\n return [incident['id'] for incident in incidents]\",\n \"def user_ids(self):\\n return list(self._user_ids)\",\n \"def get_mailing_list():\\n\\t\\tresult = {}\\n\\t\\tconnection = DbHelper.connect()\\n\\n\\t\\twith connection.cursor() as cursor:\\n\\t\\t\\tsql = \\\"SELECT email FROM mail_list \\\\\\n\\t\\t\\t\\t WHERE is_activated=1;\\\"\\n\\t\\t\\tcursor.execute(sql)\\n\\t\\t\\tresult = cursor.fetchall()\\n\\n\\t\\treturn [email_data['email'] for email_data in result]\",\n \"def get_users_for(self, email):\\r\\n # this is a list rather than a generator because we probably want to do a len() on it right away\\r\\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]\",\n \"def update_admin_ids():\\n admin_emails_config = Registry.get_config_property(\\n 'admin_emails')\\n if not admin_emails_config:\\n return []\\n\\n admin_ids = []\\n for email in admin_emails_config.value:\\n user_id = user_services.get_user_id_from_email(email)\\n if user_id is not None:\\n admin_ids.append(user_id)\\n else:\\n raise Exception('Bad admin email: %s' % email)\\n return admin_ids\",\n \"def get_read_by(self):\\n return {entry.username for entry in self.history if entry.action == MessageAction.read}\",\n \"def get_message_users(message_id):\\n if UserMessage.message_id:\\n return UserMessage.query.filter(message_id == UserMessage.message_id).all()\\n else:\\n return \\\"This message has not been sent to anybody\\\"\",\n \"def email_all():\\n\\tSubscribtion = session.query(email).all()\\n\\treturn subscribtion_object\",\n \"def get_messages(chat_id):\\n\\n mark_seen = request.args.get('mark_seen', True)\\n\\n chat = g.driver.get_chat_from_id(chat_id)\\n msgs = list(g.driver.get_all_messages_in_chat(chat))\\n\\n for msg in msgs:\\n print(msg.id)\\n\\n if mark_seen:\\n for msg in msgs:\\n try:\\n msg.chat.send_seen()\\n except:\\n pass\\n \\n return jsonify(msgs)\",\n \"def fetchmail(self):\\n mails = []\\n\\n if self.security == 'SSL/TLS':\\n imap = IMAP4_SSL(self.host, self.port)\\n else:\\n imap = IMAP4(self.host, self.port)\\n if self.security == 'STARTTLS':\\n imap.starttls()\\n imap.login(self.username, self.passwd)\\n imap.select(readonly=True)\\n\\n status, uids = imap.uid('SEARCH', 'UNSEEN')\\n\\n for uid in uids[0].split():\\n status, data = imap.uid('FETCH', uid, '(BODY[HEADER.FIELDS (DATE SUBJECT FROM)])')\\n message = self._message_from_data(data)\\n mail = Mail(uid, message['FROM'], message['SUBJECT'], message['DATE'])\\n mails.append(mail)\\n\\n imap.close()\\n imap.logout()\\n\\n return mails\",\n \"def check_user_email(self, email):\\n useremails = []\\n for user in self.__users:\\n if user['email'] == email:\\n useremails.append(user)\\n return useremails\",\n \"def getIDs():\",\n \"def readMail(m, msgNum):#Read a particular email\\n resp, data = m.fetch(msgNum, \\\"(RFC822)\\\")\\n email_body = data[0][1]\\n mail = email.message_from_string(email_body)\\n #temp = m.store(emailid,'+FLAGS', '\\\\\\\\Seen')\\n m.expunge()\\n\\n\\n return mail\",\n \"def getAssignedUsers(id=0):\\n a = [x.user_ID for x in Assignment.query.filter(Assignment.countEvent_ID == id) ]\\n return a\",\n \"def get_public_messages(self):\\n messages = []\\n for message in self.messages:\\n if message.message_id != None:\\n messages.append(message)\\n return messages\",\n \"def check_gmail(username, password):\\n i = imaplib.IMAP4_SSL('imap.gmail.com')\\n try:\\n i.login(username, password)\\n x, y = i.status('INBOX', '(MESSAGES UNSEEN)')\\n messages = int(re.search('MESSAGES\\\\s+(\\\\d+)', y[0]).group(1))\\n unseen = int(re.search('UNSEEN\\\\s+(\\\\d+)', y[0]).group(1))\\n return messages, unseen\\n except:\\n return False, 0\",\n \"def read(self):\\n return self.filter(unread=False)\",\n \"def get_uids():\\n DB_NAME = 'cloud_storage.db'\\n DB_DIRECTORY = 'server_side_storage/'\\n db = sqlite3.connect('{}{}'.format(DB_DIRECTORY, DB_NAME))\\n cursor = db.cursor()\\n cursor.execute(\\\"SELECT uid FROM user_ids\\\")\\n all_uids = cursor.fetchall()\\n db.commit()\\n cursor.close()\\n db.close()\\n all_uids = list(itertools.chain(*all_uids))\\n return all_uids\",\n \"def _get_exploration_ids_subscribed_to(self, user_id: str) -> List[str]:\\n subscriptions_model = user_models.UserSubscriptionsModel.get(\\n user_id, strict=False)\\n # TODO(#15621): The explicit declaration of type for ndb properties\\n # should be removed. Currently, these ndb properties are annotated with\\n # Any return type. Once we have proper return type we can remove this.\\n if subscriptions_model:\\n exploration_ids: List[str] = subscriptions_model.exploration_ids\\n return exploration_ids\\n else:\\n return []\",\n \"def user_ids(self):\\r\\n raise NotImplementedError\",\n \"def search(folderName):\\n\\n result, data = mailBox.select(folderName, True)\\n\\n if TESTING:\\n searchResult, uid = mailBox.uid('SEARCH', None, 'UNSEEN')\\n else:\\n searchResult, uid = mailBox.uid('SEARCH', None, 'ALL')\\n\\n number_messages = len(uid[0].split(' ')) if uid[0] != \\\"\\\" else 0\\n if number_messages == 0:\\n print \\\"\\\\nERROR: No messages found in %s\\\\n\\\" % folderName\\n print \\\"\\\\n* Exiting... *\\\\n\\\"\\n sys.exit(0)\\n print \\\"\\\\nNumber of messages in %s: %d\\\" % (folderName, number_messages)\\n\\n uidList = \\\"\\\"\\n for i in uid[0].split(' '):\\n if i.isdigit():\\n uidList += i + \\\",\\\"\\n uidList = uidList[:-1]\\n\\n return uidList\",\n \"def getEmail(self, data):\\r\\n\\t\\tprint('test')\\r\\n\\t\\t# Empty array to hold unique emails\\r\\n\\t\\tno_dp_email = []\\r\\n\\r\\n\\t\\t# Loop through each row in the dataframe...\\r\\n\\t\\tfor row in data.itertuples():\\r\\n\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t# Parse through the row's keywords string for emails...\\r\\n\\t\\t\\temails = re.findall(\\\"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Za-z]{2,4}\\\", row.keywords)\\r\\n\\t\\t\\tprint(emails)\\r\\n\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t# For each email in the array...\\r\\n\\t\\t\\tfor email in emails:\\r\\n\\t\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t\\temail = str(email)\\r\\n\\r\\n\\t\\t\\t\\t# Append this email onto the array if it is not a repeat\\r\\n\\t\\t\\t\\tif email not in no_dp_email:\\r\\n\\t\\t\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t\\t\\tno_dp_email.append(email)\\r\\n\\t\\t\\r\\n\\t\\t# return array of unique emails\\r\\n\\t\\treturn no_dp_email\",\n \"def get_message_ids_by_query(query_string, service):\\n message_results = service.users().messages().list(userId='me', q=query_string).execute()\\n if(message_results['resultSizeEstimate'] == 0):\\n return []\\n return message_results['messages'] if message_results['messages'] is not None else []\",\n \"def sender_email_notifications(self):\\n return self._sender_email_notifications\",\n \"def get_ids(self):\\n return [item.id for item in self.items]\",\n \"def mark_all_as_unread(self, recipient=None):\\n qs = self.read()\\n if recipient:\\n qs = qs.filter(recipient=recipient)\\n\\n return qs.update(unread=True)\",\n \"def fetch( self, all=0, seen=None, mark=None ):\\n conn = self._v_conn\\n indx = self._v_indx\\n msgs = []\\n\\n if seen is None:\\n seen = self._v_seen\\n if seen is None:\\n all = 1\\n mark = 0\\n\\n elif mark is None:\\n mark = 1\\n\\n if indx is None:\\n try:\\n indx = self._getUids()\\n except:\\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] error getting message index' % ( self._v_login, self.address() ), error=exc_info() )\\n raise\\n\\n #LOG( 'MailServer.fetch', TRACE, 'server has %d message(s)' % len(indx) )\\n\\n for i, uid in indx:\\n if not all and seen.has_key( uid ):\\n continue\\n\\n #LOG( 'MailServer.fetch', TRACE, 'retrieving message %d uid=%s' % (i, uid) )\\n\\n try:\\n res, lines, size = conn.retr( i )\\n except:\\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] cannot retrieve message %d uid=%s' % ( self._v_login, self.address(), i, uid ), \\\\\\n error=exc_info() )\\n continue\\n\\n try:\\n msg = self.createMessage( source=join( lines, '\\\\n') )\\n except:\\n LOG( 'MailServer.fetch', ERROR, '[%s@%s] cannot parse message %d uid=%s' % (self._v_login, self.address(), i, uid), \\\\\\n error=exc_info() )\\n continue\\n\\n msg.uid = uid\\n msgs.append( msg )\\n\\n if mark:\\n seen[ uid ] = 1\\n\\n return msgs\",\n \"def get_append_messages(self):\\n\\t\\treturn self.checkAppendMessages.get_active()\",\n \"def get_inbox(character):\\n messages = get_messages(character)\\n return [ Mail(message) for message in messages ]\",\n \"def find_expired_email(mails):\\n if not mails:\\n return []\\n\\n # get a copy of mails sort by datetime in desc order first\\n mails_date = sorted(mails, key=lambda m:m.datetime, reverse=True)\\n last7mails = mails_date[:7]\\n bmail = last7mails[-1]\\n # year|month|date => mail.mid\\n reserv_mails = { m.datetime:m.mid for m in last7mails }\\n def reserv_m(key, mail):\\n if not reserv_mails.has_key(key):\\n reserv_mails[key] = mail.mid\\n\\n for mail in mails_date[7:]:\\n if mail.datetime.year < bmail.datetime.year:\\n # mails sent in the last years, keep the newest mail per year\\n reserv_m(mail.datetime.year, mail)\\n elif mail.datetime.year == bmail.datetime.year and \\\\\\n mail.datetime.month < bmail.datetime.month:\\n # mails sent in the last months, keep the newest mail per month\\n reserv_m(mail.datetime.month, mail)\\n\\n reserv_mids = dict.fromkeys(reserv_mails.values())\\n return [m for m in mails if m.mid not in reserv_mids]\",\n \"def emails(self):\\r\\n return emails.Emails(self)\",\n \"def get_emails_in_blacklist(self, limit=0, offset=0):\\n logger.info(\\\"Function call: get_emails_in_blacklist\\\")\\n return self.__handle_result(self.__send_request('blacklist', 'GET', {'limit': limit or 0, 'offset': offset or 0}))\",\n \"def inbox(self):\\n return self._get_messages_from_folder_name('Inbox')\",\n \"def fetch(self, messages, uid):\\n return list(zip(range(1, len(self.msgObjs) + 1), self.msgObjs))\",\n \"def userAllMessages(self, uid):\\n return self.userMessages(self.userMessageBox(self.getUuidFromUid(uid)), \\\"_?([a-f]|[0-9]){8}-([a-f]|[0-9]){4}-([a-f]|[0-9]){4}-([a-f]|[0-9]){4}-([a-f]|[0-9]){12}_[0-9]+\\\")\",\n \"def get_unread_entries(self, mark_read: bool = False) -> dict[str, list[Entry]]:\\n with make_reader(self.reader_db_file) as reader:\\n unread = reader.get_entries(read=False)\\n entries = {}\\n for e in unread:\\n url = e.feed_url\\n if url in entries:\\n entries[url].append(e)\\n else:\\n entries[url] = [e]\\n\\n if mark_read:\\n reader.mark_entry_as_read(e)\\n\\n return entries\",\n \"def mark_all_notifications_as_read(self):\\n for n in Notification.objects(owner=self, unread=True):\\n n.unread = False\\n n.save()\",\n \"def unique_email_count(self):\\n return len(set(self.stripped_email_list))\",\n \"def get_pubmed_ids(self):\\n return self.pmids\",\n \"def get_message_list(self):\\n count = 0\\n for msg in self.mbox:\\n if msg['From'].find(self.config['tgt_email']) > -1:\\n dtime = arrow.get(msg['Date'], 'ddd, D MMM YYYY HH:mm:ss ZZ')\\n message = dict({'from': msg['From'],\\n 'date': dtime,\\n 'subject': msg['Subject']})\\n # boundary = msg.get_boundary()\\n # if boundary is not None:\\n # bounds = [m.start() for m\\n # in re.finditer(boundary, str(msg))]\\n # else:\\n # bounds = list()\\n # if len(bounds) > 2:\\n # message['text'] = str(msg)[bounds[1]:bounds[2]]\\n # else:\\n # message['text'] = None\\n pl = None\\n if msg['Subject'].find(\\\":\\\") == -1:\\n finished = False\\n pl = msg.get_payload()\\n while finished is False:\\n if isinstance(pl, str):\\n finished = True\\n elif isinstance(pl, list):\\n pl = pl[0].get_payload()\\n else:\\n raise ValueError(\\\"Non-list, non-str payload?\\\")\\n break\\n message['text'] = self.clean_text(str(pl))\\n\\n if message['text'] is not None:\\n self.messages.append(message)\\n count += 1\\n # print count\\n self.messages.sort(key=lambda item: item['date'])\",\n \"def checkMsgNum(m):\\n #mboxes = m.list()[1] Show all boxes\\n m.select(\\\"INBOX\\\")#Select mailbox\\n #data = m.search(None, \\\"(FROM \\\\\\\"default@gmail.com\\\\\\\")\\\") Search specific email addy\\n #Change \\\"default@gmail.com\\\" in above to a specific email address to enable search from particular user\\n items = m.search(None, \\\"(UNSEEN)\\\")\\n msgNum = str(items[1]).rsplit(None)[-1].strip('[\\\\']')\\n\\n return msgNum\",\n \"def test_alice_unread(self):\\n messages = list(self.alice_inbox.unread)\\n self.assertEqual(1, len(messages))\\n self.assertIn(self.bob_message_to_group1, messages)\\n self.assertNotIn(self.read_message, messages)\\n self.assertNotIn(self.alice_message_to_bob, messages)\\n self.assertNotIn(self.archived_message, messages)\",\n \"def getUserIds(self):\\n raise BorkedGetUserIds\",\n \"def emails(self):\\r\\n url = api_base + 'emails/'\\r\\n return json.loads(self.load_url(url))\",\n \"def _get_chat_id_list():\\n cfg = read_config()\\n cfg = cfg['notifier']['telegram_bot']\\n return cfg.get('chat_id')\",\n \"def get_messages(character):\\n mail = character.db.mail\\n try:\\n messages = [item for item in mail if item[TIMESTAMP] <= item[MESSAGE].date_sent]\\n # Let's clean up mail storage for this user while we're at it.\\n character.db.mail = messages\\n except TypeError:\\n messages = []\\n return messages\",\n \"def all_users(self):\\n distinct_users = list(self.client.smartsleep.attendees.distinct(\\\"userId\\\"))\\n return distinct_users\",\n \"def get_user_ids(session, access_token):\\n endpoint = \\\"https://graph.microsoft.com/v1.0/users?$select=id\\\"\\n r = session.get(endpoint, headers={\\\"Authorization\\\": \\\"Bearer \\\" + access_token})\\n response = json.loads(r.text)\\n return response[\\\"value\\\"]\",\n \"def list_messages(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7194147","0.70722127","0.70129013","0.69660854","0.6963227","0.6954459","0.69394183","0.69240445","0.691629","0.68746626","0.68267304","0.67761564","0.67230296","0.6694524","0.6601468","0.6559419","0.6427694","0.6418745","0.6417917","0.63268363","0.6284322","0.624063","0.6136783","0.60811406","0.6027288","0.60116124","0.5998925","0.5953211","0.59355164","0.59333926","0.58780956","0.5876546","0.5862149","0.5860406","0.5854629","0.584578","0.58447707","0.5817049","0.5785103","0.57536745","0.57369417","0.57272875","0.5721732","0.57192534","0.5715491","0.5697082","0.56670034","0.56496686","0.56457543","0.56214947","0.56195086","0.559055","0.5585871","0.5565635","0.5555886","0.5551594","0.5542551","0.5540698","0.55396825","0.55377877","0.5524926","0.5522097","0.5512508","0.55070794","0.5505787","0.5484989","0.54834306","0.54756814","0.54627174","0.5458839","0.54560536","0.54542184","0.544603","0.5441025","0.5424573","0.5418786","0.54142433","0.541167","0.54111856","0.54055053","0.5400323","0.5399624","0.5377464","0.5373745","0.536989","0.5367411","0.53665936","0.5366356","0.536604","0.53588176","0.53529596","0.5350206","0.53430927","0.5324456","0.5322389","0.53114474","0.5300758","0.5295206","0.5290128","0.5289079"],"string":"[\n \"0.7194147\",\n \"0.70722127\",\n \"0.70129013\",\n \"0.69660854\",\n \"0.6963227\",\n \"0.6954459\",\n \"0.69394183\",\n \"0.69240445\",\n \"0.691629\",\n \"0.68746626\",\n \"0.68267304\",\n \"0.67761564\",\n \"0.67230296\",\n \"0.6694524\",\n \"0.6601468\",\n \"0.6559419\",\n \"0.6427694\",\n \"0.6418745\",\n \"0.6417917\",\n \"0.63268363\",\n \"0.6284322\",\n \"0.624063\",\n \"0.6136783\",\n \"0.60811406\",\n \"0.6027288\",\n \"0.60116124\",\n \"0.5998925\",\n \"0.5953211\",\n \"0.59355164\",\n \"0.59333926\",\n \"0.58780956\",\n \"0.5876546\",\n \"0.5862149\",\n \"0.5860406\",\n \"0.5854629\",\n \"0.584578\",\n \"0.58447707\",\n \"0.5817049\",\n \"0.5785103\",\n \"0.57536745\",\n \"0.57369417\",\n \"0.57272875\",\n \"0.5721732\",\n \"0.57192534\",\n \"0.5715491\",\n \"0.5697082\",\n \"0.56670034\",\n \"0.56496686\",\n \"0.56457543\",\n \"0.56214947\",\n \"0.56195086\",\n \"0.559055\",\n \"0.5585871\",\n \"0.5565635\",\n \"0.5555886\",\n \"0.5551594\",\n \"0.5542551\",\n \"0.5540698\",\n \"0.55396825\",\n \"0.55377877\",\n \"0.5524926\",\n \"0.5522097\",\n \"0.5512508\",\n \"0.55070794\",\n \"0.5505787\",\n \"0.5484989\",\n \"0.54834306\",\n \"0.54756814\",\n \"0.54627174\",\n \"0.5458839\",\n \"0.54560536\",\n \"0.54542184\",\n \"0.544603\",\n \"0.5441025\",\n \"0.5424573\",\n \"0.5418786\",\n \"0.54142433\",\n \"0.541167\",\n \"0.54111856\",\n \"0.54055053\",\n \"0.5400323\",\n \"0.5399624\",\n \"0.5377464\",\n \"0.5373745\",\n \"0.536989\",\n \"0.5367411\",\n \"0.53665936\",\n \"0.5366356\",\n \"0.536604\",\n \"0.53588176\",\n \"0.53529596\",\n \"0.5350206\",\n \"0.53430927\",\n \"0.5324456\",\n \"0.5322389\",\n \"0.53114474\",\n \"0.5300758\",\n \"0.5295206\",\n \"0.5290128\",\n \"0.5289079\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8231231"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9476,"cells":{"query":{"kind":"string","value":"Use gmail api to find new emails Return email addresses of new emails and whether or not they have postcard"},"document":{"kind":"string","value":"def get_unread_email_data(gmail_client):\n unread_ids = get_unread_email_ids(gmail_client)\n\n for message_id in unread_ids:\n remove_unread_label = {'removeLabelIds': ['UNREAD']}\n gmail_client.users().messages().modify(userId='me', id=message_id, body=remove_unread_label).execute()\n\n message_data = gmail_client.users().messages().get(userId='me',id=message_id).execute()\n message_payload = message_data['payload']\n has_attachment = 0 < len([part for part in message_payload['parts'] if part['mimeType'] == 'image/jpeg'])\n \n message_headers = message_payload['headers']\n sender = [header['value'] for header in message_headers if header['name'] == 'Return-Path'][0]\n yield sender, has_attachment"},"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_emails():\n\n # generate the gmail api service\n service = build_gmail_api_v1()\n\n # compute date for one year ago\n today = date.today()\n one_year_ago = today - timedelta(days=365.25)\n start = one_year_ago - timedelta(days=1)\n end = one_year_ago + timedelta(days=1)\n start_string = start.strftime(\"%Y/%m/%d\")\n end_string = end.strftime(\"%Y/%m/%d\")\n query_string = f'after:{start_string} before:{end_string}'\n\n # generate the gmail api request (get list of messages from one year ago)\n request = service.users().messages().list(userId='me', q=query_string)\n\n # try to get the api response\n try:\n response = request.execute()\n except HTTPError as e:\n print('Error response status code : {0}, reason : {1}'.format(\n e.resp.status, e.error_details))\n return []\n\n # get list of message ids from the api response\n messages = list(response[\"messages\"])\n ids = [message[\"id\"] for message in messages]\n\n # store all emails in a list\n data_to_display = []\n\n # loop through each message id\n for id in ids:\n\n try:\n # store email data in a dict\n email = {}\n\n # get message data by querying gmail api using message id\n request = service.users().messages().get(userId='me', id=id)\n response = request.execute()\n\n # get date, subject, from, to, etc from message header\n headers = list(response[\"payload\"][\"headers\"])\n looking_for = [\"Date\", \"Subject\", \"From\", \"To\"]\n for header in headers:\n if header[\"name\"] in looking_for:\n email[header[\"name\"]] = header[\"value\"]\n\n # try to get message body (base64) from response\n # the json structure varies a lot so that is why there are no many try/except\n try:\n base64_message = response[\"payload\"][\"parts\"][0][\"parts\"][0][\"body\"][\"data\"]\n except (KeyError, TypeError) as e:\n try:\n base64_message = response[\"payload\"][\"parts\"][1][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n try:\n base64_message = response[\"payload\"][\"parts\"][0][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n try:\n base64_message = response[\"payload\"][\"body\"][\"data\"]\n except (KeyError, TypeError, IndexError) as e:\n base64_message = \"Ti9B\"\n\n # decode the email body\n email[\"body\"] = base64.urlsafe_b64decode(\n base64_message).decode('utf-8')\n\n # populate list with email\n data_to_display.append(email)\n\n except HTTPError as e:\n print('Error response status code : {0}, reason : {1}'.format(\n e.resp.status, e.error_details))\n\n return data_to_display","def getIdeaUrlsFromEmail():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n\n lists,nextPageToken = ListMessages(service,user_id = 'me',q='from:noreply@tradingview.com')\n # print (lists)\n mes,mes_str = GetMimeMessage(service,user_id = 'me',msg_id = lists[0]['id'])\n # print (mes)\n j = 0\n urls = []\n for part in mes.walk(): \n j = j + 1 \n fileName = part.get_filename() \n contentType = part.get_content_type() \n mycode=part.get_content_charset(); \n # 保存附件 \n if fileName:\n print ('保存邮件附件……TODO?')\n elif contentType == 'text/html': #or contentType == 'text/plain' \n #保存正文 \n data = part.get_payload(decode=True) \n content=str(data); \n # if mycode=='gb2312': \n # content= mbs_to_utf8(content) \n #end if \n # nPos = content.find('降息') \n # print(\"nPos is %d\"%(nPos)) \n # print >> f, data \n # 正则替换掉所有非 <a></a>的标签 <[^>|a]+>\n # reg = re.compile('<[^>|a]+>')\n # print (content)\n url,title = findIdeaUrlInHtml(content)\n urls.append((url,title))\n # print (url,title)\n # contentTxt = re.compile('<[^>|a]+>').sub('',content)\n # print (reg.sub('',content))\n # #end if \n\n return urls","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n messageIds = []\n i = 0\n nextPageToken = None\n while (i <= 15):\n try:\n response = service.users().messages().list(userId='me', q='after:2016/09/01', maxResults=10000, pageToken=nextPageToken).execute()\n messages = response.get('messages')\n nextPageToken = response['nextPageToken']\n\n for m in messages:\n messageIds.append(m['id'])\n\n i+=1 \n except KeyError:\n break\n\n senders = []\n counter = 0\n for i in messageIds:\n data = service.users().messages().get(userId='me', id=i).execute()\n for d in data['payload']['headers']:\n if d['name'] == 'Received':\n print(d['value'][d['value'].find('; ')+1:d['value'].find('(PST)')])\n if d['name'] == 'From' and 'bounce' not in d['value']:\n senders.append(d['value'])\n print(counter, ' ', d['value'])\n counter += 1\n break\n\n emails = []\n with open('out.csv', 'wb') as f:\n writer = csv.writer(f, delimiter=',')\n for person in set(senders):\n cleaned = clean_data(person)\n name = cleaned[0]\n email = cleaned[1]\n if email not in emails:\n emails.append(email)\n if name != None and email != None:\n writer.writerow([name, email])","def check_for_new_data():\n SCOPES = ['https://mail.google.com/']\n creds = None\n # The file token.json stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.json'):\n creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file('creds_4.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.json', 'w') as token:\n token.write(creds.to_json())\n\n service = build('gmail', 'v1', credentials=creds)\n stamp = int(time.time()) - 3600\n # Call the Gmail API\n results = service.users().messages().list(userId='me',q=f\"from:notify@google.com after:{stamp}\").execute()\n if results[\"resultSizeEstimate\"] > 0:\n populate_database()","def get_new_mails(self):\n\t\tif cint(self.settings.use_imap):\n\t\t\tself.imap.select(\"Inbox\")\n\t\t\tif self.settings.no_remaining == '0' and self.settings.uidnext:\n\t\t\t\tif self.settings.uidnext == self.settings.newuidnext:\n\t\t\t\t\treturn False\n\t\t\t\telse:\n\t\t\t\t\t#request all messages between last uidnext and new\n\t\t\t\t\treturn True\n\t\t\telse:\n\t\t\t\tresponse, message = self.imap.uid('search', None, \"ALL\")\n\t\t\temail_list = message[0].split()\n\t\telse:\n\t\t\temail_list = self.pop.list()[1]\n\n\t\treturn email_list","def check_email():\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.ehlo()\n server.login(user, password)\n\n g = gmail.login(user, password)\n\n # Check for unread messages.\n unread = g.inbox().mail(unread=True)\n\n # Submit a job to lint each email sent to editor@proselint.com. Record the\n # resulting job_ids somewhere (in Redis, I suppose), keyed by a hash of the\n # email.\n for u in unread:\n\n u.fetch()\n\n signature = (u.fr.decode('utf-8') +\n u.subject.decode('utf-8') +\n u.body.decode('utf-8'))\n\n hash = hashlib.sha256(signature.encode('utf-8')).hexdigest()\n\n if user_to in u.to or user_to in u.headers.get('Cc', []):\n\n job_id = conn.get(hash)\n\n if not job_id:\n # If the email hasn't been sent for processing, send it.\n r = requests.post(api_url, data={\"text\": u.body})\n conn.set(hash, r.json()[\"job_id\"])\n print(\"Email {} sent for processing.\".format(hash))\n\n else:\n # Otherwise, check whether the results are ready, and if so,\n # reply with them.\n r = requests.get(api_url, params={\"job_id\": job_id})\n\n if r.json()[\"status\"] == \"success\":\n\n reply = quoted(u.body)\n errors = r.json()['data']['errors']\n reply += \"\\r\\n\\r\\n\".join([json.dumps(e) for e in errors])\n\n msg = MIMEMultipart()\n msg[\"From\"] = \"{} <{}>\".format(name, user)\n msg[\"To\"] = u.fr\n msg[\"Subject\"] = \"Re: \" + u.subject\n\n if u.headers.get('Message-ID'):\n msg.add_header(\"In-Reply-To\", u.headers['Message-ID'])\n msg.add_header(\"References\", u.headers['Message-ID'])\n\n body = reply + \"\\r\\n\\r\\n--\\r\\n\" + tagline + \"\\r\\n\" + url\n msg.attach(MIMEText(body, \"plain\"))\n\n text = msg.as_string()\n server.sendmail(user, u.fr, text)\n\n # Mark the email as read.\n u.read()\n u.archive()\n\n print(\"Email {} has been replied to.\".format(hash))","def main():\r\n credentials = get_credentials()\r\n http = credentials.authorize(httplib2.Http())\r\n service = discovery.build('gmail', 'v1', http=http)\r\n\r\n response = service.users().messages().list(userId=USER_ID, labelIds=[\"SPAM\"]).execute()\r\n messages = []\r\n if 'messages' in response:\r\n messages.extend(response['messages'])\r\n\r\n while 'nextPageToken' in response:\r\n page_token = response['nextPageToken']\r\n response = service.users().messages().list(userId=USER_ID, labelIds=[\"SPAM\"], pageToken=page_token).execute()\r\n messages.extend(response['messages'])\r\n\r\n i = 0\r\n for message in messages:\r\n msg_id = message[\"id\"]\r\n message = service.users().messages().get(userId=USER_ID, id=msg_id).execute()\r\n for prop in message[\"payload\"][\"headers\"]:\r\n if prop[\"name\"] == \"From\":\r\n print(\"ID:\", i, \"\\tFrom:\", prop[\"value\"].encode('ascii','replace'), end=\"\\t\")\r\n elif prop[\"name\"] == \"Subject\":\r\n print(\"Subject:\", prop[\"value\"].encode('ascii','replace'))\r\n i += 1\r\n\r\n to_keep = raw_input(\"Do you want to keep any emails? [N / 0,1,...] \")\r\n if \",\" in to_keep:\r\n to_keep = to_keep.split(\",\")\r\n for i in range(len(to_keep)):\r\n to_keep[i] = int(to_keep[i])\r\n elif to_keep != \"N\":\r\n to_keep = [int(to_keep)]\r\n\r\n if isinstance(to_keep, list):\r\n for i in range(len(to_keep)-1,-1,-1):\r\n msg_labels = {'removeLabelIds': [\"SPAM\"], 'addLabelIds': [\"INBOX\"]}\r\n msg_id = messages[to_keep[i]][\"id\"]\r\n message = service.users().messages().modify(userId=USER_ID, id=msg_id, body=msg_labels).execute()\r\n del messages[to_keep[i]]\r\n\r\n # ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\r\n # filter0 = service.users().settings().filters().get(userId=USER_ID, id=\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\").execute()\r\n # print(filter0)\r\n\r\n for message in messages:\r\n msg_id = message[\"id\"]\r\n # for prop in message[\"payload\"][\"headers\"]:\r\n # if prop[\"name\"] == \"From\":\r\n # start_email = prop[\"value\"].find(\"<\")\r\n # end_email = prop[\"value\"].find(\">\", start_email + 1)\r\n # email_address = prop[\"value\"][start_email + 1:end_email]\r\n # filter0[\"criteria\"][\"from\"] = filter0[\"criteria\"][\"from\"] + \" OR \" + email_address\r\n service.users().messages().delete(userId=USER_ID, id=msg_id).execute()\r\n\r\n # service.users().settings().filters().delete(userId=USER_ID, id=\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\").execute()\r\n # service.users().settings().filters().create(userId=USER_ID, body=filter0).execute()\r\n print(\"All Spam Deleted!\")","def checkEmail():\n\tpop_conn = poplib.POP3_SSL('pop.gmail.com')\n\tpop_conn.user('')\n\tpop_conn.pass_('')\n\t#Get messages from server:\n\tmessages = [pop_conn.retr(i) for i in range(1, len(pop_conn.list()[1]) + 1)]\n\t# Concat message pieces:\n\tmessages = [\"\\n\".join(mssg[1]) for mssg in messages]\n\t#Parse message intom an email object:\n\tmessages = [parser.Parser().parsestr(mssg) for mssg in messages]\n\tflag = 0\n\tsweep = None\n\tfor message in messages:\n\t\tsubject = message['subject']\n\t\tif subject is None:\n\t\t\tcontinue\n\t\telif \"CommenceSweep:\" in subject:\n\t\t\tstart = subject.find(\":\")\n\t\t\tcommand = subject[start+1:]\n\t\t\tprint command\n\t\t\tif \"Comp\"+sys.argv[1] in command:\n\t\t\t\tstart = command.find(\"-\")\n\t\t\t\tsweep = command[start+1:]\n\t\t\t\tprint sweep\n\t\t\t\tpoplist = pop_conn.list()\n\t\t\t\tmsglist = poplist[1]\n\t\t\t\tfor msgspec in msglist:\n\t\t\t\t\tdelete = int(msgspec.split(' ')[0])\n\t\t\t\t\tpop_conn.dele(delete)\n\t\t\t\tflag = 1\n\tpop_conn.quit()\n\treturn flag, sweep","def main(): \r\n # Creating a storage.JSON file with authentication details\r\n # we are using modify and not readonly, as we will be marking the messages \r\n # as Read \r\n SCOPES = 'https://www.googleapis.com/auth/gmail.modify' \r\n store = file.Storage('storage.json') \r\n creds = store.get()\r\n if not creds or creds.invalid:\r\n flow = client.flow_from_clientsecrets('client_secret.json', SCOPES)\r\n creds = tools.run_flow(flow, store)\r\n GMAIL = discovery.build('gmail', 'v1', http=creds.authorize(Http()))\r\n \r\n messages_retrieved=0\r\n num_images=0\r\n save_dir,search_term = read_prefs() \r\n \r\n # Getting all the unread messages from Inbox\r\n unread_msgs = GMAIL.users().messages().list(userId='me',\r\n labelIds=['INBOX', 'UNREAD']).execute()\r\n \r\n # We get a dictonary. Now reading values for the key 'messages'\r\n try:\r\n mssg_list = unread_msgs['messages']\r\n print (\"Total unread messages in inbox: \", str(len(mssg_list)))\r\n except KeyError: #handle the keyerror on no new messages by exiting\r\n print ('No new messages - exiting.')\r\n return 0 \r\n \r\n #loop through the new messages list\r\n for i,mssg in enumerate(mssg_list):\r\n temp_dict = { }\r\n print(\"processing message {} of {}\".format(i+1,len(mssg_list)))\r\n m_id = mssg['id'] # get id of individual message\r\n # fetch the message using API\r\n message = GMAIL.users().messages().get(userId='me', id=m_id).execute() \r\n payld = message['payload'] # get payload of the message \r\n header = payld['headers'] # get header of the payload\r\n \r\n for field in header: # getting the Subject\r\n if field['name'] == 'Subject':\r\n msg_subject = field['value']\r\n temp_dict['Subject'] = msg_subject\r\n if field['name'] == 'Date':\r\n msg_date = field['value']\r\n date_parse = (parser.parse(msg_date))\r\n m_date = (date_parse.date())\r\n temp_dict['Date'] = str(m_date)\r\n else:\r\n pass\r\n \r\n try:\r\n\r\n # Fetching message body\r\n try: #if there is html/data only\r\n part_data = payld['body']['data'] # fetching data\r\n except: #if there are multiple parts get the html part\r\n part_data = payld['parts'][0]['body']['data'] # fetching data from the body\r\n # decoding from Base64 to UTF-8\r\n clean_one = part_data.replace(\"-\",\"+\").replace(\"_\",\"/\")\r\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) \r\n \r\n if search_term in temp_dict['Subject']:\r\n img_list= soup_process_email(clean_two.decode(\"utf8\"))\r\n print ('{} images found.'.format(len(img_list)))\r\n \r\n for i in (img_list):\r\n print (\"downloading: \" +i.split('/')[-1])\r\n #adding the email date to filepath\r\n write_dir=save_dir+temp_dict['Date']+'/'\r\n #checking if path exists (and making it if not)\r\n ensure_dir(write_dir) \r\n if \".jpg\" in i:\r\n # adding filename to write path\r\n write_dir=write_dir+\"/\"+i.split('/')[-1] \r\n else:\r\n # adding 'mp4' extension to movies and removing leading '?'\r\n filename=str(i.split('/')[-1])\r\n write_dir=write_dir+\"/\"+filename[1:]+\".mp4\" \r\n # check if file exists\r\n if not does_file_exist(write_dir):\r\n time.sleep(1) #rate limiting\r\n urllib.request.urlretrieve(i, write_dir) #downloading\r\n # num_images+=len(img_list)\r\n num_images+=1\r\n else:\r\n print ('file already downloaded')\r\n \r\n else:\r\n pass \r\n messages_retrieved+=1\r\n except Exception as e:\r\n print (\"Unexpected error:\", sys.exc_info()[0])\r\n print (\"Unexpected error:\", sys.exc_info()[1])\r\n print (\"Unexpected error:\", sys.exc_info()[2])\r\n except:\r\n pass \r\n \r\n #### This will mark the messages as read. when testing is complete\r\n GMAIL.users().messages().modify(userId='me', \r\n id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \r\n \r\n \r\n print (\"Total messages retrieved: \", messages_retrieved)\r\n print (\"Total images retrieved: \", num_images)","def search_email_advanced(M):\n print \"\\n==============================\"\n print \"Search emails in advanced mode\"\n print \"==============================\\n\"\n\n till_date = 50\n date_range = datetime.date.today() - datetime.timedelta(till_date)\n date = date_range.strftime(\"%d-%b-%Y\")\n # rv, data = M.uid('search', None, \\\n # '(SENTSINCE {date} FROM \"lmxvip@hotmail.com\")'.format(date=date))\n rv, data = M.uid(\n 'search',\n None,\n '(SENTSINCE {date} FROM \"cindyyueweiluo@gmail.com\")'\n .format(date=date)\n )\n if check_response(rv):\n return data\n else:\n return None","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n service = build('gmail', 'v1', credentials=creds)\n\n user_id = 'me'\n label_id_one = 'INBOX'\n label_id_two = 'UNREAD'\n\n # Call the Gmail API\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n unread_msgs = service.users().messages().list(userId='me',labelIds=[label_id_one, label_id_two]).execute()\n mssg_list = unread_msgs['messages']\n print (\"Total unread messages in inbox: \", str(len(mssg_list)))\n final_list = [ ]\n\n for mssg in mssg_list:\n temp_dict = { }\n m_id = mssg['id'] # get id of individual message\n message = service.users().messages().get(userId=user_id, id=m_id).execute() # fetch the message using API\n payld = message['payload'] # get payload of the message \n headr = payld['headers'] # get header of the payload\n\n\n for one in headr: # getting the Subject\n if one['name'] == 'Subject':\n msg_subject = one['value']\n temp_dict['Subject'] = msg_subject\n else:\n pass\n\n\n for two in headr: # getting the date\n if two['name'] == 'Date':\n msg_date = two['value']\n date_parse = (parser.parse(msg_date))\n m_date = (date_parse.date())\n temp_dict['Date'] = str(m_date)\n else:\n pass\n\n for three in headr: # getting the Sender\n if three['name'] == 'From':\n msg_from = three['value']\n temp_dict['Sender'] = msg_from\n else:\n pass\n\n temp_dict['Snippet'] = message['snippet'] # fetching message snippet\n\n\n try:\n \n # Fetching message body\n mssg_parts = payld['parts'] # fetching the message parts\n part_one = mssg_parts[0] # fetching first element of the part \n part_body = part_one['body'] # fetching body of the message\n part_data = part_body['data'] # fetching data from the body\n clean_one = part_data.replace(\"-\",\"+\") # decoding from Base64 to UTF-8\n clean_one = clean_one.replace(\"_\",\"/\") # decoding from Base64 to UTF-8\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) # decoding from Base64 to UTF-8\n soup = BeautifulSoup(clean_two , \"lxml\" )\n mssg_body = soup.body()\n # mssg_body is a readible form of message body\n # depending on the end user's requirements, it can be further cleaned \n # using regex, beautiful soup, or any other method\n temp_dict['Message_body'] = mssg_body\n\n except :\n pass\n\n print (temp_dict)\n final_list.append(temp_dict) # This will create a dictonary item in the final list\n return final_list[:3]\n # This will mark the messagea as read\n #service.users().messages().list(userId=user_id, id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \n\n\n if not labels:\n print('No labels found.')\n else:\n print('Labels:')\n for label in labels:\n print(label['name'])","def main():\n \n ####GET ALL MESSAGES FROM GMAIL###\n # gmail_usr_name = raw_input(\"Enter the gmail user name: \\n\")\n # gmail_passwrd = getpass.getpass(\"Enter the Gmail password: \\n\")\n print(\"Please wait while message IDs for Gmail are populated...\")\n gmail_accumulator = Accumulator.Accumulator(GMAIL_PATH, \"usr_name\", \"passwrd\",\n IMAP_PORT, GMAIL_FOLDER)\n gmail_msg_ids = gmail_accumulator.get_ids()\n pprint.pprint(gmail_msg_ids)\n \n ####GET ALL MESSAGES FROM IMAP###\n #IMAP2_usr_name = raw_input(\"Enter the IMAP2 user name: \\n\")\n #IMAP2_passwrd = getpass.getpass(\"Enter the IMAP2 password: \\n\")\n print(\"Please wait while message IDs for IMAP are populated\")\n \n IMAP2_accumulator = Accumulator.Accumulator(\"imap2.lbl.gov\", \"usr_name\", \"passwrd\",\n IMAP_PORT, IMAP2_FOLDER)\n IMAP2_msg_ids = IMAP2_accumulator.get_ids()\n pprint.pprint(IMAP2_msg_ids)\n \n gmail_unique_ids = gmail_accumulator.get_unique_ids()\n ###FIND THE DIFFERENCES BETWEEN IMAP AND GMAIL.####\n compare_ids = Comparator.Comparator(IMAP2_msg_ids, gmail_unique_ids)\n diff_ids = compare_ids.compare()\n \n ###FIND THE DUPLICATE IDs FROM IMAP2.###\n \n dups = IMAP2_accumulator.get_duplicate_ids()\n dup_headers = header_info(dups, IMAP2_accumulator)\n print(\"{num_msgs} messages in IMAP2/{fldr}\\n\".format(num_msgs = IMAP2_accumulator.count_ids(), fldr = IMAP2_accumulator.folder))\n print(\"{num_msgs} messages in GMAIL/{fldr}\\n\".format(num_msgs = gmail_accumulator.count_ids(), fldr = gmail_accumulator.folder))\n \n print(\"-------------------------------------------------------------------------------------\")\n print(\"There are {num} messages in IMAP2/{fldr1} which are not in Gmail/{fldr2}\\n\".format(num = len(diff_ids),\n fldr1 = IMAP2_accumulator.folder,\n fldr2 = gmail_accumulator.folder))\n print(\"--------------------------------------------------------------------------------------\")\n pprint.pprint(diff_ids)\n\n print(\"Here is a list of the headers of each message ID which is not in Gmail:\\n\")\n headers = header_info(diff_ids, IMAP2_accumulator)\n\n ###print a table of the info of the missing messages.###\n table = prettytable.PrettyTable([\"TO\", \"FROM\", \"SUBJECT\"])\n table.align[\"TO\"] = \"l\"\n table.padding_width = 1\n for hdr in headers:\n table.add_row(hdr)\n print(table)\n\n\n ###write the output to OUTPUT_FILE.###\n\n output_file = open(OUTPUT_FILE, 'w')\n output_file.write(\"\\n\")\n output_file.write(\"{num_msgs} messages in IMAP2/{fldr}\\n\".format(num_msgs = IMAP2_accumulator.count_ids(), fldr = IMAP2_accumulator.folder))\n output_file.write(\"{num_msgs} messages in GMAIL/{fldr}\\n\".format(num_msgs = gmail_accumulator.count_ids(), fldr = gmail_accumulator.folder))\n output_file.write(\"There are {num} messages in IMAP2/{fldr1} which are not in Gmail/{fldr2} \\n\".format(num = len(diff_ids),\n fldr1 = IMAP2_accumulator.folder,\n fldr2 = gmail_accumulator.folder))\n output_file.write(\"Here is a list of the headers of each message ID which is not in Gmail:\\n\")\n for ids in diff_ids:\n output_file.write(str(ids))\n output_file.write(\"\\n\")\n output_file.write(\"\\n\")\n\n ###OUUTPUT THE TABLE###\n\n output_file.write(str(table)) \n output_file.write(LINE_SEPARATOR)\n\n output_file.close()\n\n ucb.interact()","def test_get_all_email_address(self):\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\n email_addr2 = 'test_get_all_email_addr' + '@' + self.email_dom\n org = 'o=%s' % (self.org_name)\n people = '%s=%s' % (self.container_attr, self.user_container)\n uid = '%s=%s' % (self.user_key, self.user_id)\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\n dn_info = {self.smtp_address: [email_addr, email_addr2]}\n expected_result = [(dn, dn_info)] \n addr = SpokeEmailAddress(self.org_name, self.user_id)\n addr.create(email_addr)\n addr.create(email_addr2)\n result = addr.get()['data']\n self.assertEqual(result, expected_result)","def get_emails(parsed_data):\n result = []\n known_values = []\n contacts = {'registrant_contact': [], 'administrative_contact': [], 'technical_contact': [],\n 'domain_registrar': []}\n if 'registrant_contact' in parsed_data:\n contacts['registrant_contact'].append(parsed_data['registrant_contact'])\n if 'administrative_contact' in parsed_data:\n contacts['administrative_contact'].append(parsed_data['administrative_contact'])\n if 'technical_contact' in parsed_data:\n contacts['technical_contact'].append(parsed_data['technical_contact'])\n if 'domain_registrar' in parsed_data:\n contacts['domain_registrar'].append(parsed_data['domain_registrar'])\n # parsing email address from contact block\n\n for contact, info in contacts.items():\n if info is not None:\n d = {'type': 2, 'data': '', 'properties': {}, 'special_properties': {}, 'is_valid': False, 'ref': {}}\n # properties dictionary\n is_valid = {}\n owner = {'owner': '', 'type': 11}\n organization = {'organization': '', 'type': 11}\n local_address = {'local_address': '', 'type': 5}\n domain_name = {'domain_name': '', 'type': 12}\n properties_list = []\n special_properties_list = []\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': ''}})\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\n d['ref']['whois_for'] = parsed_data['domain_name']\n if 'whois_server' in parsed_data:\n d['ref']['whois_from'] = parsed_data['whois_server']\n\n for name in info:\n if \"email_address\" in name:\n if name['email_address'] in known_values:\n break\n for feature in name.keys():\n if feature == \"email_address\":\n d['data'] = name['email_address']\n known_values.append(name['email_address'])\n\n if feature == \"full_name\":\n owner['owner'] = name['full_name']\n properties_list.append(owner)\n\n if feature == \"city_name\":\n organization['organization'] = name['city_name']\n properties_list.append(organization)\n\n d['is_valid'] = ''\n is_valid = {'isvalid': '', 'type': 0}\n\n # prevent from create result if phone number of contact is not available\n if d['data'] == '':\n continue\n try:\n domain_name['domain_name'] = d['data'].split('@')[1]\n local_address['local_address'] = d['data'].split('@')[0]\n properties_list.append(domain_name)\n properties_list.append(local_address)\n except:\n\n domain_name['domain_name'] = ''\n local_address['local_address'] = d['data']\n properties_list.append(domain_name)\n properties_list.append(local_address)\n\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': '', 'label': ''}})\n d['ref']['label'] = \"%s_name\" % contact\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\n d['ref']['whois_for'] = parsed_data['domain_name']\n if 'whois_server' in parsed_data:\n d['ref']['whois_from'] = parsed_data['whois_server']\n d['properties'] = properties_list\n special_properties_list.append(is_valid)\n d['special_properties'] = special_properties_list\n result.append(d)\n\n return result","def gmail(screen):\n\n\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n\n\n if not labels:\n print('No labels found.')\n else:\n if PRINT_CATEGORY: print('Labels:')\n for label in labels:\n if PRINT_CATEGORY: print(label['name'])\n if label['name']=='UNREAD':\n listMessages = ListMessagesWithLabels(service, 'me', label['name'])\n nbMessages = len(listMessages)\n nbMess = 0\n\n printTerminal('ENZO! Tu as ['+str(nbMessages)+'] messages non lus.',True)\n say('ENZO! Tu as: '+str(nbMessages)+' messages non lus.')\n\n for message in listMessages:\n #print(GetMessage(service, 'me', message['id'], False))\n nbMess+=1\n ggMessage = GetMessage(service, 'me', message['id'], False)\n #print(ggMessage)\n\n #msg_str = base64.urlsafe_b64decode(ggMessage['raw'].encode('ASCII'))\n #print(msg_str)\n\n for header in ggMessage['payload']['headers']:\n #print(header)\n if header['name']=='Subject':\n #unicode(text,'utf-8')\n #screen.addstr(0,1,\"\")\n if screen:\n screen.addstr(str(nbMess)+'] '+header['value'])\n say(header['value'])\n screen.refresh()\n else:\n print(str(nbMess)+'] '+header['value'])\n say(header['value'])\n #TTS(header['value'],'french', 50 ,2 )\n #status=subprocess.call([\"espeak\",\"-s 100 -v fr \",header['value']], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n\n #for part in ggMessage['payload']['parts']:\n # msg = base64.urlsafe_b64decode(part['body']['data'].encode('ASCII'))\n # print(removehtml(msg))\n #print(part['body']['data'])\n #say(part['body']['data'])\n if len(sys.argv) > 1:\n if sys.argv[1]=='-t':\n TTS(ggMessage,'french', 50 ,2 )\n #for toto in label:\n # print(toto)","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n\n lists,nextPageToken = ListMessages(service,user_id = 'me',q='subject:tradingview')\n # print (lists)\n mes,mes_str = GetMimeMessage(service,user_id = 'me',msg_id = lists[0]['id'])\n print (mes)\n\n\n j = 0\n for part in mes.walk(): \n j = j + 1 \n fileName = part.get_filename() \n contentType = part.get_content_type() \n mycode=part.get_content_charset(); \n # 保存附件 \n if fileName:\n print ('hhhhhhhhhhhhh')\n elif contentType == 'text/plain' or contentType == 'text/html': \n #保存正文 \n data = part.get_payload(decode=True) \n content=str(data); \n # if mycode=='gb2312': \n # content= mbs_to_utf8(content) \n #end if \n # nPos = content.find('降息') \n # print(\"nPos is %d\"%(nPos)) \n # print >> f, data \n # 正则替换掉所有非 <a></a>的标签 <[^>|a]+>\n # reg = re.compile('<[^>|a]+>')\n contentTxt = re.compile('<[^>|a]+>').sub('',content)\n print (reg.sub('',content))\n #end if \n\n\n \n # help(mes)\n # for i in mes.values():\n # print (i)\n # # print (mes[i]);\n # print (\"----------\")\n # print (mes['from'])\n # print (type (mes))\n # # print \n # parsed = Parser().parsestr(mes)\n # print (parsed)\n # print (mes)\n # for i in mes:\n # print (i)\n # for item in lists:\n # mes = GetMimeMessage(service,user_id = 'me',msg_id = item['id'])\n # # print (mes)\n # parsed = Parser().parsestr(mes)\n # print (parsed)","def get_email_info_from_all_addressbooks(self, email):\n logger.info(\"Function call: get_email_info_from_all_addressbooks for '{}'\".format(email, ))\n return self.__handle_error('Empty email') if not email else self.__handle_result(self.__send_request('emails/{}'.format(email, )))","def emails(self):\r\n url = api_base + 'emails/'\r\n return json.loads(self.load_url(url))","def get_email_addresses(startdate, enddate, user, password):\n emails = []\n page = 1\n more_pages = True\n\n while more_pages:\n response = requests.get(\n 'https://restapi.surveygizmo.com/v2/survey/{survey}'\n '/surveyresponse?'\n 'filter[field][0]=datesubmitted'\n '&filter[operator][0]=>=&filter[value][0]={start}+0:0:0'\n '&filter[operator][1]=<&filter[value][1]={end}+0:0:0'\n '&filter[field][1]=status&filter[operator][1]=='\n '&filter[value][1]=Complete'\n '&resultsperpage=500'\n '&page={page}'\n '&user:pass={user}:{password}'.format(\n survey=EMAIL_COLLECTION_SURVEY_ID, start=startdate,\n end=enddate, page=page, user=user, password=password))\n\n results = json.loads(response.content)\n total_pages = results['total_pages']\n more_pages = page < total_pages\n emails = emails + [r['[question(13)]'] for r in results['data']]\n\n return emails","def main():\n creds = None\n # The file token.pickle stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first time.\n scores = {} # scores is an empty dict already\n\n if os.path.getsize('token.pickle') > 0: \n with open('token.pickle', \"rb\") as f:\n unpickler = pickle.Unpickler(f)\n # if file is not empty scores will be equal\n # to the value unpickled\n scores = unpickler.load()\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n creds = pickle.load(token)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.pickle', 'wb') as token:\n pickle.dump(creds, token)\n\n # Starts Gmail V1 with logged in user\n service = build('gmail', 'v1', credentials=creds)\n \n# ================================================================================== \n\n\n # MAIL CHECKHER ================================================================\n\n # get mails via gmail api\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\n messages = results.get('messages', [])\n\n # mail number\n mail_nr = 0\n\n # variabel for how many mails we want to search through\n message_count = int(input(\"Hur många mails vill du söka igenom? \"))\n # if 0 mails are chosen\n if not messages:\n print('Inga mail i inkorgen')\n else:\n # looks through the email inbox for mails \"message_count\" amount of times\n for message in messages[:message_count]:\n # gets the email id's in full format so we can extraqct information via the gmail api\n msg = service.users().messages().get(userId='me', id=message['id'], format='full', metadataHeaders=None).execute()\n # gets the headers of the email in a variable\n headers = msg[\"payload\"][\"headers\"]\n # from headers gets the sender email, who it was from \n from_ = [i['value'] for i in headers if i[\"name\"]==\"From\"]\n # from headers gets the subject of the email\n subject = [i['value'] for i in headers if i[\"name\"]==\"Subject\"]\n # keeps count of the current email\n mail_nr += 1\n # if the email is from the security system email print it's information\n if from_ == ['Python Ormarna <python.ormar@gmail.com>'] or from_ == ['python.ormar@gmail.com']:\n # gets the email in raw format via gmail api\n rawmsg = service.users().messages().get(userId=\"me\", id=message[\"id\"], format=\"raw\", metadataHeaders=None).execute()\n print(\"=\"*100)\n print(\"\\nMail:\", mail_nr)\n print(\"Detta mail är från erat säkerhetssystem\")\n # variable the UNIX time of when the email was sent\n datum = int(msg['internalDate'])\n datum /= 1000\n # prints the date and time when the email was revived in local y/m/d/h/m/s\n print(\"Mottaget:\", datetime.fromtimestamp(datum).strftime('%Y-%m-%d %H:%M:%S'))\n print(\"Från:\", from_)\n print(\"Ämne:\", subject)\n # prints a snippet from the email\n print(msg['snippet'])\n print(\"\\n\")\n else:\n print(\"=\"*100)\n print(\"\\nMail:\", mail_nr)\n print(\"Detta mail är INTE från erat säkerhetssystem\\n\")\n time.sleep(1)\n print(\"Inga fler mail hittades\")","def get_from_email(column_names, start_dates, end_dates, mail_server,\n account, sender, password):\n time_flag = None\n dfs = {test: pd.DataFrame(columns=column_names[test]) \\\n for test in [\"covid_ag\", \"flu_ag\"]}\n start_date = compare_dates(start_dates[\"covid_ag\"],\n start_dates[\"flu_ag\"], \"s\")\n end_date = compare_dates(end_dates[\"covid_ag\"],\n end_dates[\"flu_ag\"], \"l\")\n\n with MailBox(mail_server).login(account, password, 'INBOX') as mailbox:\n for search_date in [start_date + timedelta(days=x)\n for x in range((end_date - start_date).days + 1)]:\n for message in mailbox.fetch(A(AND(date=search_date.date(), from_=sender))):\n for att in message.attachments:\n name = att.filename\n\n # Check the test type\n if \"Sars\" in name:\n test = \"covid_ag\"\n elif \"Flu\" in name:\n test = \"flu_ag\"\n else:\n continue\n\n # Check whether we pull the data from a valid time range\n whether_in_range = check_whether_date_in_range(\n search_date, start_dates[test], end_dates[test])\n if not whether_in_range:\n continue\n\n print(f\"Pulling {test} data received on %s\"%search_date.date())\n toread = io.BytesIO()\n toread.write(att.payload)\n toread.seek(0) # reset the pointer\n newdf = pd.read_excel(toread) # now read to dataframe\n newdf = regulate_column_names(newdf, test)\n dfs[test] = dfs[test].append(newdf)\n time_flag = search_date\n return dfs, time_flag","def search_email_by_all(M):\n print \"basic search mode\\n\"\n rv, data = M.uid('search', None, 'All')\n if check_response(rv):\n return data\n else:\n return None","def get_emails(print_list, email_dict):\n\n email_list = []\n again = True\n contact_table = PrettyTable()\n contact_table.field_names = [\"Command\", \"Advisor Name\", \"Email\"]\n\n for row in print_list:\n contact_table.add_row(row)\n\n while again:\n print(contact_table)\n pretty_print(email_list, \":\")\n pretty_print(\"To Add Receiving Emails Enter the corresponding command number\", \"-\")\n pretty_print(\"To Send Mail press any number key:\", \"-\")\n choice = get_int_input()\n if choice in email_dict.keys():\n email_list.append(email_dict[choice])\n\n else:\n if len(email_list) != 0:\n again = False\n\n else:\n again = True\n pretty_print(\"No Email Added\", \"-\")\n\n clear()\n\n return email_list","def gmail(arg):\n if not arg:\n return GOOGLE_MAIL\n search_content = arg\n account_num = '0'\n ret_url = GOOGLE_MAIL + account_num + (('/#search/' + search_content) if search_content else '')\n print('returning url {}'.format(ret_url))\n return ret_url","def get_email_addresses(survey, startdatetime, enddatetime):\n token = settings.SURVEYGIZMO_API_TOKEN\n secret = settings.SURVEYGIZMO_API_TOKEN_SECRET\n emails = []\n page = 1\n more_pages = True\n survey_id = SURVEYS[survey][\"email_collection_survey_id\"]\n dtfmt = \"%Y-%m-%d+%H:%M:%S\"\n\n # Can't do anything without credentials.\n if token is None or secret is None:\n return emails\n\n while more_pages:\n response = requests.get(\n \"https://restapi.surveygizmo.com/v2/survey/{survey}\"\n \"/surveyresponse?\"\n \"filter[field][0]=datesubmitted\"\n \"&filter[operator][0]=>=&filter[value][0]={start}\"\n \"filter[field][1]=datesubmitted\"\n \"&filter[operator][1]=<&filter[value][1]={end}\"\n \"&filter[field][2]=status&filter[operator][2]==\"\n \"&filter[value][2]=Complete\"\n \"&resultsperpage=500\"\n \"&page={page}\"\n \"&api_token={token}\"\n \"&api_token_secret={secret}\".format(\n survey=survey_id,\n start=startdatetime.strftime(dtfmt),\n end=enddatetime.strftime(dtfmt),\n page=page,\n token=token,\n secret=secret,\n ),\n timeout=300,\n )\n\n results = json.loads(response.content)\n total_pages = results.get(\"total_pages\", 1)\n more_pages = page < total_pages\n emails = emails + [r[\"[question(13)]\"] for r in results[\"data\"]]\n page += 1\n\n valid_emails = []\n for email in emails:\n try:\n validate_email(email)\n except ValidationError:\n pass\n else:\n valid_emails.append(email)\n\n return valid_emails","def _get_unread_emails(conn):\n pattern = re.compile('^\\d+\\ \\(ENVELOPE\\ \\(\"(.*?)\"\\ \"(.*?)\"\\ \\(\\(\"(.*?)\"\\ .*?\\ \"(.*?)\"\\ \"(.*?)\"\\)\\).*$')","def test_get_missing_email_account(self):\n acc = SpokeEmailAccount(self.org_name, self.user_id)\n email_addr = 'missing@' + self.email_dom\n result = acc.get(email_addr)['data']\n expected_result = []\n self.assertEqual(result, expected_result)","def audit_emails_in_metadata(self):\n\n # Iterate over commits....\n disallowed_domains = [\"localhost\", \"localhost.localdomain\", \"(none)\", \"bombardier.com\", \"rail.bombardier.com\"]\n for commit in self.repository.commits.values():\n for email_address in [ commit.committer_email, commit.author_email ]:\n # Extract the email address, and reject them if extraction fails....\n extraction = re.match(\"^(\\S+)@(\\S+)$\", email_address)\n if not extraction:\n self.__log_failure(commit.sha1, \"Seemingly invalid email address: \" + email_address)\n continue\n\n # Don't allow domains which are disallowed...\n domain = extraction.group(2)\n if domain in disallowed_domains:\n self.__log_failure(commit.sha1, \"Email address using a blocked domain: \" + email_address)\n continue\n\n # Ensure they have a valid MX/A entry in DNS....\n try:\n dns.resolver.query(domain, \"MX\")\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel):\n try:\n dns.resolver.query(domain, \"A\")\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel, dns.resolver.NXDOMAIN):\n self.__log_failure(commit.sha1, \"Email address has an invalid domain : \" + email_address)\n except (dns.resolver.NXDOMAIN, dns.resolver.NoNameservers):\n self.__log_failure(commit.sha1, \"Email address has an invalid domain : \" + email_address)","def test_get_email_address(self):\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\n org = 'o=%s' % (self.org_name)\n people = '%s=%s' % (self.container_attr, self.user_container)\n uid = '%s=%s' % (self.user_key, self.user_id)\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\n dn_info = {self.smtp_address: [email_addr]}\n expected_result = [(dn, dn_info)] \n addr = SpokeEmailAddress(self.org_name, self.user_id)\n addr.create(email_addr)\n result = addr.get(email_addr)['data']\n self.assertEqual(result, expected_result)","def test_get_email_account(self):\n email_addr = self.user_id + '@' + self.email_dom\n org = '%s=%s' % (self.org_attr, self.org_name)\n people = '%s=%s' % (self.container_attr, self.user_container)\n uid = '%s=%s' % (self.user_key, self.user_id)\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\n dn_info = {self.imap_enable: ['TRUE'],\n self.imap_mailbox: [self.user_id],\n self.imap_domain: [self.email_dom],\n self.imap_partition: [self.imap_partition_def],\n self.smtp_destination: [email_addr],\n self.smtp_enable: ['TRUE'],\n self.smtp_pri_address: [email_addr]\n }\n expected_result = [(dn, dn_info)] \n acc = SpokeEmailAccount(self.org_name, self.user_id)\n result = acc.get(self.email_addr)['data']\n self.assertEqual(result, expected_result)","def update_from_emails(self, emails):\n # Now add contributors using cache (new GitHub contributors) with known email or orcid that isn't present\n for email in emails:\n if email not in self.email_lookup:\n bot.info(f\" Updating with new added email: {email}\")\n entry = {\"@type\": \"Person\", \"email\": email}\n self.lookup.append(entry)","def getEmail(self, data):\r\n\t\tprint('test')\r\n\t\t# Empty array to hold unique emails\r\n\t\tno_dp_email = []\r\n\r\n\t\t# Loop through each row in the dataframe...\r\n\t\tfor row in data.itertuples():\r\n\t\t\tprint('test')\r\n\r\n\t\t\t# Parse through the row's keywords string for emails...\r\n\t\t\temails = re.findall(\"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}\", row.keywords)\r\n\t\t\tprint(emails)\r\n\t\t\tprint('test')\r\n\r\n\t\t\t# For each email in the array...\r\n\t\t\tfor email in emails:\r\n\t\t\t\tprint('test')\r\n\r\n\t\t\t\temail = str(email)\r\n\r\n\t\t\t\t# Append this email onto the array if it is not a repeat\r\n\t\t\t\tif email not in no_dp_email:\r\n\t\t\t\t\tprint('test')\r\n\r\n\t\t\t\t\tno_dp_email.append(email)\r\n\t\t\r\n\t\t# return array of unique emails\r\n\t\treturn no_dp_email","def main():\n token = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-token.json'\n credential = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-credentials.json'\n creds = None\n # The file token.json stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n if os.path.exists(token):\n creds = Credentials.from_authorized_user_file(token, SCOPES)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n credential, SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n # with open('token.json', 'w') as token:\n # token.write(creds.to_json())\n\n service = build('gmail', 'v1', credentials=creds)\n\n # # Call the Gmail API\n # results = service.users().labels().list(userId='me').execute()\n # labels = results.get('labels', [])\n #\n # if not labels:\n # print('No labels found.')\n # else:\n # print('Labels:')\n # for label in labels:\n # print(label['name'])\n\n # Call the Gmail API to fetch INBOX\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\n messages = results.get('messages', [])\n # message1 = messages[0]\n # print(message1)\n message1 = {'id': '17a5ca5f5f4bd0aa', 'threadId': '17a5b1bb861b3bc2'}\n message1 = {'id': '17a5cbc54c546465', 'threadId': '17a5b1bb861b3bc2'}\n\n # message1 = {'id': '17a5b852afe04a52', 'threadId': '17a50c997c059e68'}\n print(messages)\n print(message1)\n\n if not messages:\n print(\"No messages found.\")\n else:\n print(\"Message snippets:\")\n # for message in messages:\n # msg = service.users().messages().get(userId='me', id=message['id']).execute()\n # print(messages)\n # print(msg['snippet'])\n\n # msg = service.users().messages().get(userId='me', id=message1['id']).execute()\n # print(msg['snippet'])\n ###############################\n msg = service.users().messages().get(userId='me', id=message1['id'], format='raw').execute()\n msg_str = base64.urlsafe_b64decode(msg['raw'].encode('ASCII'))\n mime_msg = email.message_from_bytes(msg_str)\n print(msg['snippet'])\n print(mime_msg)\n print(mime_msg['Date'])\n print(mime_msg['From'])\n print(mime_msg['To'])\n print(mime_msg['Subject'])\n #\n # print(datetime.utcnow())\n\n ######################################################\n # msg = service.users().messages().get(userId='me', id=message1['id'], format='full').execute()\n # # parts can be the message body, or attachments\n # payload = msg['payload']\n # headers = payload.get(\"headers\")\n # parts = payload.get(\"parts\")\n # # print(payload)\n # # print(parts)\n # # print(headers)\n # for header in headers:\n # print(header['name'])\n # print(header['value'])\n #\n ######################################################\n msg = service.users().messages().get(userId='me', id=message1['id']).execute()\n\n # Use try-except to avoid any Errors\n try:\n # Get value of 'payload' from dictionary 'txt'\n payload = msg['payload']\n headers = payload['headers']\n subject = ''\n sender = ''\n\n # Look for Subject and Sender Email in the headers\n for d in headers:\n if d['name'] == 'Subject':\n subject = d['value']\n if d['name'] == 'From':\n sender = d['value']\n # The Body of the message is in Encrypted format. So, we have to decode it.\n # Get the data and decode it with base 64 decoder.\n parts = payload.get('parts')[0]\n data = parts['body']['data']\n data = data.replace(\"-\", \"+\").replace(\"_\", \"/\")\n decoded_data = base64.b64decode(data)\n\n # Now, the data obtained is in lxml. So, we will parse\n # it with BeautifulSoup library\n soup = BeautifulSoup(decoded_data, \"lxml\")\n body = soup.body()\n\n # Printing the subject, sender's email and message\n print(\"Subject: \", subject)\n print(\"From: \", sender)\n print(\"Message: \", body)\n # for link in soup.find_all('a', href=True):\n # print(link['href'])\n link = soup.find('a', href=True)\n print(link['href'])\n except:\n pass","def test_get_all_email_domains(self):\n email_dom2 = 'testgetall.com'\n org = 'o=%s' % (self.org_name)\n dn = '%s,%s' % (org, self.base_dn)\n dn_info = {'aenetPostfixDomain': [self.email_dom, email_dom2]}\n expected_result = [(dn, dn_info)] \n domain = SpokeEmailDomain(self.org_name)\n domain.create(email_dom2)\n result = domain.get()['data']\n self.assertEqual(result, expected_result)","def ValidateEmails(contacts):\n contacts = [c.strip() for c in contacts.strip().split(',') if c.strip()]\n contact_emails = [utils.GetEmailAddress(c) for c in contacts]\n try:\n user_service = service_factory.GetUserInfoService()\n person_hash = user_service.GetUserInfoMulti(contact_emails)\n # Suppress pylint catch Exception\n # pylint: disable-msg=W0703\n except errors.ServiceCriticalError:\n person_hash = {}\n\n res = []\n for contact, contact_email in zip(contacts, contact_emails):\n item = {'input': contact, 'email': contact_email, 'name': contact}\n if contact_email in person_hash:\n item['name'] = person_hash[contact_email].name\n res.append(item)\n\n return res","def email_all():\n\tSubscribtion = session.query(email).all()\n\treturn subscribtion_object","def send(self):\n msg_sent = []\n subs = mongo.db.subscribers\n bill_extractor = ExtractBills()\n \n # Do not need the object ID\n same_interval = subs.find({\"interval\":self.interval}, {'_id':0})\n \n for each in same_interval:\n email = each['email']\n tags = each['search_tags']\n state = each['state']\n chamber = each['chamber']\n print(email, tags)\n\n msg_for_rcpnt = bill_extractor.getBill(state, chamber, tags)\n #all_candidates.append((email, msg_for_rcpnt))\n \n #try:\n # msg_body = \"hello world\"\n # msg_body = render_template('mail_card.html')\n # msg = Message(msg_body,\n # sender=\"mssshaown@gmail.com\",\n # recipients=email)\n # mail.send(msg) \n # msg_sent.append((email, \"Success\"))\n #except Exception as e:\n # msg_sent.append((email, str(e)))\n #return msg_sent\n return msg_for_rcpnt","def scrape_emails(webpage):\n emails = []\n html = requests.get(webpage)\n email_regex = re.compile(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z]+')\n emails = email_regex.findall(html.text)\n return emails","def get_group_of_emails(M):\n print \"Try to access group of emails\"\n data = search_email_advanced(M)\n if data is None:\n return\n # print \"Got data as \", data\n ids = data[0]\n id_list = ids.split()\n for id_num in id_list:\n rv, data = M.uid('fetch', id_num, \"(RFC822)\")\n if rv != \"OK\":\n print \"Error getting message\"\n return\n # get raw text of the whole email\n raw_email = data[0][1]\n content = email.message_from_string(raw_email)\n # print raw_email\n p = EmailParser()\n # print sender and receivers\n print \"To: \", content['To'], \"\\n\"\n print \"From: \", email.utils.parseaddr(content['From']), \"\\n\"\n print \"Date: \", content['Date'], \"\\n\"\n print \"Subject: \", p.parsestr(raw_email).get('Subject'), \\\n \"\\n\"\n result = parse_content(content)\n # print results\n printData(result)","def get_email_addresses(r):\n email_match = re.findall(r'[\\w.-]+@[\\w.-]+.\\w+', r)\n email_list = []\n if email_match:\n for match in email_match:\n if match not in email_list:\n email_list.append(match)\n email_list = set(email_list)\n return email_list","def go():\n # Authenticate\n print('****************** Authenticate ******************')\n\n creds = None\n\n if os.path.exists('token.pickle'):\n with open('token.pickle', 'rb') as token:\n print('****************** Load Token ******************')\n\n creds = pickle.load(token)\n\n if not creds or not creds.valid:\n print('****************** Credentials ******************')\n\n if creds and creds.expired and creds.refresh_token:\n print('****************** Refresh Credentials ******************')\n\n creds.refresh(Request())\n else:\n print('****************** Load Credentials ******************')\n\n flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n\n with open('token.pickle', 'wb') as token:\n print('****************** Dump Token ******************')\n\n pickle.dump(creds, token)\n\n print('****************** Load Service ******************')\n\n service = build('gmail', 'v1', credentials=creds)\n\n # Set Date Range\n print('****************** Set Date Range ******************')\n \n start_datetime = datetime.today() - timedelta(days=2)\n end_datetime = datetime.today() + timedelta(days=2)\n\n start_date = start_datetime.strftime(\"%Y/%m/%d\")\n end_date = end_datetime.strftime(\"%Y/%m/%d\")\n\n print(start_date)\n print(end_date)\n\n # Set Query\n print('****************** Set Query ******************')\n\n user_id = 'me'\n full = 'full'\n query = 'after:' + start_date + ' before:' + end_date + ' subject:Your Single Transaction Alert from Chase'\n\n print(query)\n\n # List Messages (All Pages)\n print('****************** Run Query ******************')\n\n response = service.users().messages().list(userId=user_id, q=query).execute()\n\n messages_all_pages = []\n\n if 'messages' in response:\n messages_all_pages.extend(response['messages'])\n\n while 'nextPageToken' in response:\n page_token = response['nextPageToken']\n response = service.users().messages().list(userId=user_id, q=query, pageToken=page_token).execute()\n messages_all_pages.extend(response['messages'])\n\n messages = messages_all_pages\n\n # Find Transactions in Message List\n if not messages:\n print('No messages found...')\n else:\n for message in messages:\n queue_id = message['id']\n\n # Get Message\n this_message = service.users().messages().get(userId=user_id, id=queue_id, format=full).execute()\n\n # Set Message\n message_body = this_message['payload']['body']['data']\n message_html = base64.urlsafe_b64decode(message_body)\n message_text = message_html.decode('utf-8').replace('($USD) ', '')\n\n # Set Transaction Date\n date_message = int(this_message['internalDate'])\n date_object = (date_message / 1000)\n transaction_date = datetime.fromtimestamp(date_object).strftime(\"%Y-%m-%d\")\n\n # Set Amount\n amount = re.search('A charge of (.+?) at', message_text).group(1)\n\n # Set Description\n description = re.search('at (.+?) has', message_text).group(1)\n\n # Build Transaction\n transaction = {\n 'QueueID': queue_id,\n 'TransactionTypeID': 2,\n 'TransactionDT': transaction_date,\n 'Description': description,\n 'Amount': amount,\n 'BudgetCategoryID': '103',\n 'TransactionNumber': '',\n 'Note': 'CC'\n }\n\n print('****************** Transaction Found ******************')\n print(transaction)\n\n # Send to Queue\n response_data = requests.post(url=BUDGET_API, data=transaction)\n\n result = response_data.text\n\n if result == '1':\n print('****************** Transaction Queued ******************')","def test_06_get_person_by_email(self):\n p1 = Person.query.first()\n p1_data = p1.wrap()\n p1_email = p1_data[\"email\"]\n q_string = \"?email={}\".format(p1_email[2:10]) # TODO - verify the length of email before slicing\n rv = self.app.get('persons', query_string=q_string)\n data = json.loads(rv.data)\n self.assertEqual(data[\"count\"], 1)","def fetch_all(self):\n emails = []\n res, messages = self._mailconn.search(None, 'ALL')\n if res == 'OK':\n for msg in messages[0].split():\n try:\n res, data = self._mailconn.fetch(msg.decode('utf-8'), '(RFC822)')\n except Exception as error:\n self.close_mail_connection()\n print('No email to read: '+error)\n exit()\n \n msg = email.message_from_string((data[0][1]).decode('utf-8'))\n if not isinstance(msg, str):\n if self.is_sender_in_whitelist(msg['From']):\n emails.append(msg)\n\n return emails","def test_get_missing_email_address(self):\n addr = SpokeEmailAddress(self.org_name, self.user_id)\n email_addr = 'missing@' + self.email_dom\n result = addr.get(email_addr)['data']\n expected_result = []\n self.assertEqual(result, expected_result)","def _print_basic_email_information(emails, conn):\n for mid in emails:\n (res, data) = conn.fetch(mid, '(ENVELOPE)')\n headers = pattern.match(data[0])\n print 'Date: %s' % headers.group(1)\n print 'Subject: %s' % headers.group(2)\n print 'From: %s <%s@%s>' % (headers.group(3), headers.group(4), headers.group(5))\n print","def check_for_subscribers(mail, login_info):\n ADDRESS, PASSWORD = login_info\n\n try:\n mail.select('inbox')\n data = mail.search(None, 'ALL') \n except:\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\n mail.login(ADDRESS, PASSWORD)\n mail.select('inbox')\n data = mail.search(None, 'ALL')\n \n mail_ids = data[1]\n id_list = mail_ids[0].split() \n\n if not id_list:\n return []\n\n first_email_id = int(id_list[0])\n latest_email_id = int(id_list[-1])\n\n subscribers = []\n\n for i in range(latest_email_id, first_email_id-1, -1):\n data = mail.fetch(str(i), '(RFC822)')\n for response_part in data:\n arr = response_part[0]\n if isinstance(arr, tuple):\n msg = email.message_from_string(str(arr[1],'utf-8'))\n email_from = msg['from']\n subscribers.append(email_from)\n\n return subscribers","def search_email_by_time(M):\n print \"search mail by time\\n\"\n date = (datetime.date.today() - datetime.timedelta(1)).strftime(\"%d-%b-%Y\")\n rv, data = M.uid('search', None, '(SENTSINCE {date})'.format(date=date))\n if check_response(rv):\n return data\n else:\n return None","def isEmailUsed(self, email):\n\n\t\ttestq = {\"email\": email};\n\t\ttest_result = self.db.request(\"getOne\", testq);\n\n\t\tif test_result:\n\t\t\treturn True;\n\t\telse:\n\t\t\treturn False;","def find_expired_email(mails):\n if not mails:\n return []\n\n # get a copy of mails sort by datetime in desc order first\n mails_date = sorted(mails, key=lambda m:m.datetime, reverse=True)\n last7mails = mails_date[:7]\n bmail = last7mails[-1]\n # year|month|date => mail.mid\n reserv_mails = { m.datetime:m.mid for m in last7mails }\n def reserv_m(key, mail):\n if not reserv_mails.has_key(key):\n reserv_mails[key] = mail.mid\n\n for mail in mails_date[7:]:\n if mail.datetime.year < bmail.datetime.year:\n # mails sent in the last years, keep the newest mail per year\n reserv_m(mail.datetime.year, mail)\n elif mail.datetime.year == bmail.datetime.year and \\\n mail.datetime.month < bmail.datetime.month:\n # mails sent in the last months, keep the newest mail per month\n reserv_m(mail.datetime.month, mail)\n\n reserv_mids = dict.fromkeys(reserv_mails.values())\n return [m for m in mails if m.mid not in reserv_mids]","def generate_email_address(count: int = 1) -> list:\n\n pass","def fetch_mailbox((mailbox, host, user, passwd)):\r\n\r\n global text, attachments\r\n\r\n ## login to the pop3 server ==============================\r\n print\r\n print \"###### Connecting to %s\" % host\r\n M = poplib.POP3(host)\r\n M.set_debuglevel(1)\r\n M.user(user)\r\n M.pass_(getpass.getpass())\r\n\r\n ## create the mailbox and attachments directories if required\r\n if not os.path.exists (mailboxdir):\r\n print \"Creating Directory %s\", mailboxdir\r\n os.mkdir (mailboxdir)\r\n\r\n att_dir = \"%s\\\\att_%s\" % (mailboxdir, mailbox)\r\n if not os.path.exists (att_dir):\r\n print \"Creating Directory %s\", att_dir\r\n os.mkdir (att_dir)\r\n\r\n \r\n ## get list of uidls in the mailbox file =================\r\n uidls = get_mailbox_uidls(mailbox)\r\n\r\n ## get number of messages ================================\r\n numMessages = len(M.list()[1])\r\n print \"There are %d messages on the server\" % numMessages\r\n\r\n\r\n ## get uidls from server and compare with the uidls in the\r\n ## mailbox ===============================================\r\n uidls_srv = M.uidl()\r\n list = uidls_srv[1]\r\n fetchlist = []\r\n for item in list:\r\n msgno, uidl = item.split(' ')\r\n msgno = int(msgno)\r\n if not uidl in uidls:\r\n print \"Found new message: (%d, %s)\" % (msgno, uidl)\r\n fetchlist.append(msgno)\r\n\r\n print \"There are %d new messages on the server\" % len(fetchlist)\r\n\r\n alltext = \"\" ## this variable contains the mbox contents\r\n\r\n ## go over all of the emails =============================\r\n for i in fetchlist:\r\n\r\n flatmsg = \"\"\r\n\r\n ## retreive message\r\n# for line in M.retr(i+1)[1]:\r\n for line in M.retr(i)[1]:\r\n flatmsg += line + \"\\r\\n\"\r\n\r\n ## parse message\r\n msg = email.message_from_string (flatmsg)\r\n\r\n ## handle Email.message object\r\n title = handleMsg(mailbox, msg)\r\n\r\n\r\n msgtext = \"%s\\n%s* UIDL: %s\\n%s\\n\\n\" % (''.center(70,'#'), title, uidl, text)\r\n if not attachments == \"\":\r\n msgtext += \"#### Attachments:\\n%s\" % attachments\r\n\r\n alltext = msgtext.replace('\\r\\n','\\n') + alltext\r\n\r\n ## add 'alltext' to the beginning of the mailbox file ====\r\n mboxfile = \"%s\\\\%s.mbx\" % (mailboxdir, mailbox)\r\n contents = \"\"\r\n if os.path.exists(mboxfile):\r\n mbox = open(mboxfile, \"rt\")\r\n contents = mbox.read()\r\n mbox.close()\r\n\r\n mbox = open(mboxfile, \"wt\")\r\n mbox.write (alltext)\r\n if contents != \"\":\r\n mbox.write (contents)\r\n\r\n mbox.close()\r\n\r\n return len(fetchlist)","def get_duplicate_emails():\n UserModel = get_user_model()\n users = UserModel.objects.all()\n emails_seen = {}\n duplicate_emails = []\n for user in users:\n email = user.email.lower()\n if email in emails_seen:\n duplicate_emails.append(email)\n else:\n emails_seen[email] = True\n return duplicate_emails","def getIssuesEmail(self):\r\n base_url = \"http://beta.boost.org/development/tests/\"\r\n base_url += self.branch\r\n base_url += \"/developer/\";\r\n got_issues = False\r\n\r\n # Ping the server by looking for an HTML file\r\n print \"Pinging the server to initiate extraction...\"\r\n ping_url = base_url + \"issues.html\"\r\n os.system('curl -O ' + ping_url)\r\n os.system('rm -f issues.html')\r\n \r\n for x in range(30):\r\n # Update issues-email.txt\r\n url = base_url + \"issues-email.txt\"\r\n print 'Retrieving issues email from ' + url\r\n os.system('rm -f issues-email.txt')\r\n os.system('curl -O ' + url)\r\n\r\n if self.parseIssuesEmail():\r\n return True\r\n\r\n print 'Failed to fetch issues email. '\r\n time.sleep (30)\r\n\r\n return False","def get_messages(self):\n\t\tif not self.check_mails():\n\t\t\treturn # nothing to do\n\n\t\tfrappe.db.commit()\n\n\t\ttry:\n\t\t\t# track if errors arised\n\t\t\tself.errors = False\n\t\t\tself.latest_messages = []\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\tuid_validity = self.get_status()\n\t\t\telse:\n\t\t\t\temail_list = self.get_new_mails()\n\n\n\t\t\t# size limits\n\t\t\tself.total_size = 0\n\t\t\tself.max_email_size = cint(frappe.local.conf.get(\"max_email_size\"))\n\t\t\tself.max_total_size = 5 * self.max_email_size\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\t#try:\n\t\t\t\tif self.check_uid_validity(uid_validity):\n\t\t\t\t\temail_list = self.get_new_mails()\n\t\t\t\t\tif email_list:\n\t\t\t\t\t\tself.get_imap_messages(email_list)\n\t\t\t\t\tself.sync_flags()\n\t\t\t\t\tself.get_seen()\n\t\t\t\t\tself.push_deleted()\n\n\t\t\t\telse:\n\t\t\t\t\tpass\n\n\t\t\telse:\n\t\t\t\tnum = num_copy = len(email_list)\n\n\t\t\t\t# WARNING: Hard coded max no. of messages to be popped\n\t\t\t\tif num > 20: num = 20 #20\n\n\t\t\t\tfor i, message_meta in enumerate(email_list):\n\t\t\t\t\t# do not pull more than NUM emails\n\t\t\t\t\tif (i+1) > num:\n\t\t\t\t\t\tbreak\n\n\t\t\t\t\ttry:\n\t\t\t\t\t\tself.retrieve_message(message_meta, i+1)\n\t\t\t\t\texcept (TotalSizeExceededError, EmailTimeoutError, LoginLimitExceeded):\n\t\t\t\t\t\tbreak\n\n\t\t\t\t# WARNING: Mark as read - message number 101 onwards from the pop list\n\t\t\t\t# This is to avoid having too many messages entering the system\n\t\t\t\tnum = num_copy\n\t\t\t\tif not cint(self.settings.use_imap):\n\t\t\t\t\tif num > 100 and not self.errors:\n\t\t\t\t\t\tfor m in xrange(101, num+1):\n\t\t\t\t\t\t\tself.pop.dele(m)\n\n\t\texcept Exception, e:\n\t\t\tif self.has_login_limit_exceeded(e):\n\t\t\t\tpass\n\n\t\t\telse:\n\t\t\t\traise\n\n\t\tfinally:\n\t\t\t# no matter the exception, pop should quit if connected\n\t\t\tif cint(self.settings.use_imap):\n\t\t\t\tself.imap.logout()\n\t\t\telse:\n\t\t\t\tself.pop.quit()\n\n\t\treturn self.latest_messages","def test_good_email():\n good_email = \"me@dom.com\"\n m = CannedRe.EMAIL.match(good_email)\n # print getmembers(m)\n assert m is not None, \"Canned RegEx email test failed for %s\" % good_email\n assert m.string == good_email","def get_mailing_list():\n\t\tresult = {}\n\t\tconnection = DbHelper.connect()\n\n\t\twith connection.cursor() as cursor:\n\t\t\tsql = \"SELECT email FROM mail_list \\\n\t\t\t\t WHERE is_activated=1;\"\n\t\t\tcursor.execute(sql)\n\t\t\tresult = cursor.fetchall()\n\n\t\treturn [email_data['email'] for email_data in result]","def email_lookup(self):\n if not hasattr(self, \"_email_lookup\"):\n self._email_lookup = {}\n self.load_data()\n for entry in self.data.get(\"contributor\", []):\n if \"email\" in entry:\n self._email_lookup[entry[\"email\"]] = entry\n return self._email_lookup","def person_didnt_downloaded_same_apps(other_email = 'rbaudibert@inf.ufrgs.br'):\n try:\n query = run_select_query('SELECT email \\\n FROM \"User\" u \\\n WHERE NOT EXISTS ( \\\n SELECT * \\\n FROM download \\\n WHERE (u.email = download.user_email) \\\n AND item_id IN ( \\\n SELECT item_id \\\n FROM download \\\n WHERE (user_email = %s) \\\n ) \\\n );', (other_email,))\n return [{'email': obj[0]} for obj in query]\n except (Exception, psycopg2.Error) as error:\n return {\"status\": \"error\", \"error\": error}","def readMail(m, msgNum):#Read a particular email\n resp, data = m.fetch(msgNum, \"(RFC822)\")\n email_body = data[0][1]\n mail = email.message_from_string(email_body)\n #temp = m.store(emailid,'+FLAGS', '\\\\Seen')\n m.expunge()\n\n\n return mail","def get_emails(params, start_response):\n custodian = params.getfirst('custodian')\n date = params.getfirst('date')\n tfidf = params.getfirst('tfidf')\n out = json.dumps(documents_out(custodian, date, tfidf))\n status = '200 OK'\n response_headers = [('Content-type', 'application/json'),\n ('Access-Control-Allow-Origin', '*'),\n ('Content-Length', str(len(out)))]\n start_response(status, response_headers)\n return [out]","def get(self, email, application_category):","def getMail():\n\n while 1:\n #if 1==1:\n \n try:\n Mailbox = poplib.POP3(c.Server['host'], c.Server['port']) \n Mailbox.user(c.Server['username']) \n Mailbox.pass_(c.Server['password']) \n numMessages = len(Mailbox.list()[1])\n \n \n log.info(\"Connected to %s and there are %i messages\"%(c.Server['host'], numMessages))\n \n for i in range(numMessages):\n msg = Mailbox.top(i+1, 10000)\n #msg = Mailbox.retr(i+1) # removes messages\n qIncomingMail.put(msg)\n log.debug(\"getMail: put message %i in queue\"%i)\n Mailbox.quit()\n \n except:\n log.error(\"Failed to connect to %s\"%c.Server['host'])\n time.sleep(60)","def get_accounts_for_emails(cls, emails):\n return cls.get_by_key_name(['<%s>' % email for email in emails])","def get_emails(self, token):\n user_email_url = get_config('login.github.emails_info_url')\n headers = {\n \"Authorization\": \"token %s\" % token\n }\n email_info_resp = get_remote(user_email_url, headers)\n email_list = json.loads(email_info_resp)\n\n return email_list","def get_messages(email: str) -> list:\n\n params = {\"action\": \"getMessages\", \"login\": email, \"domain\": domain}\n\n response = requests.get(endpoint, data=params)\n email_data = json.load(response)\n\n for email_message in email_data:\n for field, value in email_message.items():\n print(f\"{field}: {value}\")\n print()","def add(self, emails):\r\n request = http.Request('POST', self.get_url(), emails)\r\n\r\n return request, parsers.parse_json","def update_mailing_list_extended(mailing_list):\r\n\r\n # Creating a copy of the original mailing list\r\n # This is necessary because we are going to exclude some keys (pop)\r\n mailing_list_copy = dict(mailing_list)\r\n\r\n # Looping over the mailing list and extracting key and value\r\n for key, value in mailing_list_copy.items():\r\n\r\n # Checks it the flag `opt-out` is present. We use lower() here to lowercase the flags and contemplate both\r\n # `opt-out` and `OPT-OUT` cases\r\n # Then, checks for the presence of the `unsubscribed` flag Finally,\r\n # checks if the email address contains `@gmail` provider\r\n if ('opt-out' in value[2].lower()) or \\\r\n ('unsubscribed' in value[2].lower()) or \\\r\n ('@gmail' in value[1]):\r\n # Remove the key if one of the above conditions is satisfied\r\n mailing_list.pop(key)\r\n\r\n # An array to collect the final output\r\n ids = []\r\n\r\n # Sort the updated mailing list alphabetically by `nickname`\r\n for items in sorted(mailing_list.items(), key=itemgetter(1), reverse=False):\r\n # Appending only the ids of the active users\r\n ids.append(items[0])\r\n\r\n # Returns the updated mailing list with the active users\r\n return ids","def _ListReviewsForEmailAddress(self, email_address, output_writer):\n issue_numbers = set()\n\n cursor = None\n while True:\n download_url = (\n u'https://codereview.appspot.com/search?reviewer={0:s}'\n u'&format=json&keys_only=False&with_messages=True').format(\n email_address)\n\n # TODO: for now only search open issues.\n # 1 => Unknown\n # 2 => Yes\n # 3 => No\n if not self._include_closed:\n download_url = u'{0:s}&closed=3'.format(download_url)\n\n if cursor:\n download_url = u'{0:s}&cursor={1:s}'.format(download_url, cursor)\n\n reviews_data, response = self._DownloadPageContent(download_url)\n if not reviews_data:\n break\n\n # TODO: check if response is not None\n _ = response\n\n reviews_json = json.loads(reviews_data)\n\n for review_values in self._ParserReviewsJSON(reviews_json):\n if review_values[0] in issue_numbers:\n # Skip issues numbers we've already processed.\n return\n\n issue_numbers.add(review_values[0])\n\n # TODO: add in review status.\n if review_values[5]:\n status = u'closed'\n elif review_values[4]:\n status = u'in review'\n else:\n status = u'new'\n\n if not self._include_closed:\n reviewers = u', '.join(review_values[4])\n output_line = u'{0:s}\\t{1:s}\\t{2:d}\\t{3:s}\\t{4:s}\\t{5:s}\\n'.format(\n review_values[0], review_values[1], review_values[2],\n review_values[3], reviewers, status)\n output_writer.Write(output_line.encode(u'utf-8'))\n\n else:\n # Create a row per reviewer.\n for reviewer in review_values[4]:\n output_line = u'{0:s}\\t{1:s}\\t{2:d}\\t{3:s}\\t{4:s}\\t{5:s}\\n'.format(\n review_values[0], review_values[1], review_values[2],\n review_values[3], reviewer, status)\n output_writer.Write(output_line.encode(u'utf-8'))\n\n cursor = reviews_json.get(u'cursor', None)","def emails_parse(emails_dict):\n result = emails_dict['ListVerifiedEmailAddressesResponse'][\n 'ListVerifiedEmailAddressesResult']\n emails = [email for email in result['VerifiedEmailAddresses']]\n\n return sorted(emails)","def send_emails():\n\n cmd = \"sendmail -f git@dev.rtsoft.ru\"\n for msg in EMAIL_MESSAGES:\n for rec in RECIPIENTS:\n call(\"echo '%s' | %s %s\" % (msg, cmd, rec), None, True)","def get_emails_stat_by_campaigns(self, emails):\n logger.info(\"Function call: get_emails_stat_by_campaigns\")\n if not emails:\n self.__handle_error(\"Empty emails\")\n try:\n emails = json.dumps(emails)\n except:\n logger.debug(\"Emails: {}\".format(emails))\n return self.__handle_error(\"Emails list can't be converted by JSON library\")\n return self.__handle_result(self.__send_request('emails/campaigns', 'POST', {'emails': emails}))","def create_user_emails_sheets_all():\n input_range = \"Sheet1\"\n\n sheetsService = build(\n 'sheets', 'v4', credentials=credentials, cache_discovery=False)\n\n # Empty sheet\n sheetsService.spreadsheets().values().clear(\n spreadsheetId=spreadsheet_id, range=input_range).execute()\n\n # Get all basic users' email\n users = list(User.objects.filter(is_active=True,\n role=\"BU\").values('email', 'username', 'role', 'profile_id'))\n\n # Check their consent status and update accordingly\n subscribers = []\n for user in users:\n if user['profile_id'] != None:\n profile = SubscriberProfile.objects.get(id=user['profile_id'])\n status = profile.consent_status\n if status == \"IMPLIED\" and profile.expired_at < date.today():\n profile.consent_status = \"EXPIRED\"\n profile.save()\n elif status == \"EXPRESSED\" or status == \"IMPLIED\":\n user.pop('profile_id')\n subscribers.append(user)\n # Get newsletter only users' email\n nlusers = list(NLUser.objects.all())\n\n # Check their consent status and update accordingly\n for nluser in nlusers:\n status = nluser.consent_status\n if status == \"IMPLIED\" and nluser.expired_at < date.today():\n nluser.consent_status = \"EXPIRED\"\n nluser.save()\n elif status == \"EXPRESSED\" or status == \"IMPLIED\":\n subscribers.append({\"email\": nluser.email, \"username\": nluser.first_name,\n \"role\": \"NL\"})\n\n # Get all basic users' email\n restaurant_owners = list(\n User.objects.filter(is_active=True, role=\"RO\").values('email', 'username', 'role'))\n\n # Append user info into values (only users that has email verified)\n values = [['Email', 'Username', 'Role']]\n for subscriber in subscribers:\n values.append(list(subscriber.values()))\n for restaurant_owner in restaurant_owners:\n values.append(list(restaurant_owner.values()))\n\n body = {\n 'values': values\n }\n\n try:\n sheetsService.spreadsheets().values().update(spreadsheetId=spreadsheet_id, range=input_range,\n valueInputOption=\"USER_ENTERED\", body=body).execute()\n except HttpError as error:\n print('An error occurred: %s' % error)\n raise error\n # return None\n\n # Automatically format the sheets\n requests = [\n {\n \"autoResizeDimensions\": {\n \"dimensions\": {\n \"sheetId\": 0,\n \"dimension\": \"COLUMNS\",\n \"startIndex\": 0,\n \"endIndex\": 3\n }\n }\n },\n {\n \"repeatCell\": {\n \"range\": {\n \"sheetId\": 0,\n \"startRowIndex\": 0,\n \"endRowIndex\": 1,\n \"startColumnIndex\": 0,\n \"endColumnIndex\": 3\n },\n \"cell\": {\n \"userEnteredFormat\": {\n \"textFormat\": {\n \"bold\": True\n }\n }\n },\n \"fields\": \"userEnteredFormat(textFormat)\"\n }\n }\n ]\n\n body = {\n 'requests': requests\n }\n\n try:\n sheetsService.spreadsheets().batchUpdate(\n spreadsheetId=spreadsheet_id, body=body).execute()\n except HttpError as error:\n print('An error occurred: %s' % error)\n raise error","def test_check_email(self):\n url = reverse('check_email')\n data = {\"emails\": [\"shashank.shekhar@vgmail.in\"]}\n response_data = {\"results\": [{\"email\": \"shashank.shekhar@vgmail.in\", \"blocked\": True}], \"success\": True}\n response = self.client.post(url, data, format='json')\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data, response_data)","def enrich_user_by_email(email):\n\n result = {}\n if settings.ENRICH_DATA:\n clearbit.key = settings.CLEARBIT_API_KEY\n try:\n result = clearbit.Enrichment.find(email=email, stream=True)\n except:\n result = {}\n\n return result","def test_check_email_endpoint(self, **kwargs):\n email_id = kwargs.get('email_id', Workflows.generate_new_email(suffix=self.global_config[\"email_id_suffix\"]))\n client_id = kwargs.get('client_id', self.global_config[\"client_id\"])\n client_secret = kwargs.get('client_secret', self.global_config[\"client_secret\"])\n relative_url = kwargs.get('url', self.test_args[\"relative_url\"]).format(email_id, client_id, client_secret)\n\n restapi = Rest(base_uri=self.global_config[\"base_url\"])\n response = restapi.get(relative_url=relative_url, **kwargs)\n if kwargs.get(\"return_response_obj\", False):\n return response\n\n print(\"Verify Response body\")\n assert json.loads(response.text)[\"data\"][\"available\"] == self.test_args[\"expected_result\"], \"Test Failed\"\n return None","def IP_list(pwd):\r\n # Connect to the gmail server.\r\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\r\n mail.login('arc.pi.reg@gmail.com', pwd)\r\n\r\n # get mail IDs.\r\n mail.select('Inbox')\r\n typ, data = mail.search(None, '(From \"arc.pi.reg\")')\r\n mail_ids = data[0].decode()\r\n id_list = mail_ids.split()\r\n\r\n pi_ip = []\r\n\r\n # More description here.\r\n for id in id_list[::-1]:\r\n typ, msg_data = mail.fetch(id, '(BODY.PEEK[TEXT])')\r\n msg = msg_data[0][1].decode().strip()\r\n\r\n name, addr = msg.split(\" \")\r\n pi_ip.append((name, addr))\r\n\r\n return pi_ip","def checkUserEmail(email, number):\n\n if number == 1:\n flag = 0\n atflag = False\n for i in email:\n if i == \"@\":\n atflag=True\n flag += 1\n if i == \".\" and atflag:\n flag += 1\n if flag != 2:\n return False\n return True\n if number == 2:\n c.execute(\"select email from users where email = ?\", (email,))\n if c.fetchall():\n return True\n return False","def test_skip_blank_emails(self):\n appt_date = datetime.date.today() + datetime.timedelta(days=7) # Default for email\n confirmed = self.create_confirmed_notification(self.test_patient, appt_date)\n\n blank_contact = self.create_contact(data={'email': ''})\n self.group.contacts.add(blank_contact)\n\n # run email job\n from aremind.apps.reminders.app import daily_email_callback\n daily_email_callback(self.router)\n\n self.assertEqual(len(mail.outbox), 1)\n message = mail.outbox[0]\n self.assertEqual(len(message.to), 1)","def check_mail(self, update=False):\r\n return self.check_mail_dir(update=update)","def send_email(recent_seach_tweets):\n # Create e-mail message\n msg = C.intro + C.message_init.format(number_flash_cards=len(recent_seach_tweets))\n # Add a special text for the first 3 new tweets \n for tw in recent_seach_tweets[:3]:\n date = tw['date'].strftime('Le %d/%m/%Y à %H:%M')\n link_tweet = tw['tweet_link']\n link_picture = tw['images'][0]\n tweet_text = tw[\"text\"][:tw[\"text\"].index('#')-1]\n msg += C.flashcard.format(date=date, \n link_picture=link_picture, \n tweet_text=tweet_text,\n tweet_link=link_tweet)\n\n # mapping for the subject\n numbers = { 0 : 'zero', 1 : 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5 : 'five',\n 6 : 'six', 7 : 'seven', 8 : 'eight', 9 : 'nine', 10 : 'ten'}\n\n message = MIMEText(msg, 'html')\n message['From'] = formataddr((str(Header('Twitter Parser', 'utf-8')), C.my_email_address))\n message['To'] = C.dest\n message['Subject'] = '%s new Machine Learning Flash Cards' % numbers[len(recent_seach_tweets)].title()\n msg_full = message.as_string()\n\n server = smtplib.SMTP('smtp.gmail.com:587')\n server.starttls()\n server.login(C.my_email_address, C.password)\n server.sendmail(C.my_email_address, C.dest, msg_full)\n server.quit()\n print('%s - E-mail sent!' % datetime.datetime.now().strftime('%d/%m/%Y - %H:%M'))","def check_gmail(username, password):\n i = imaplib.IMAP4_SSL('imap.gmail.com')\n try:\n i.login(username, password)\n x, y = i.status('INBOX', '(MESSAGES UNSEEN)')\n messages = int(re.search('MESSAGES\\s+(\\d+)', y[0]).group(1))\n unseen = int(re.search('UNSEEN\\s+(\\d+)', y[0]).group(1))\n return messages, unseen\n except:\n return False, 0","def test_email_search(self):\n # A name in the database\n search_string = \"umut@gmail.com\"\n # Search For Umut\n resp = SearchTest.client.get('/api/search/',{\"token\":SearchTest.valid_token,\"search_string\":search_string})\n search_result = json.loads(resp.content)\n # Check the e_mail field of the result\n self.assertEqual(search_string,search_result[0]['e_mail'],\"It doesn't return the user with the email {}\".format(search_string))","def extract_emails_from_category(initial_url, first_page=int(1)):\r\n\tresult_emails = set() #we will return this\r\n\t#last page regex\r\n\tlp_regex = re.compile('[0-9]+/;')\r\n\t#Open URL\r\n\tsoup = bs4.BeautifulSoup(urlopen(initial_url), \"html5lib\")\r\n\t#extract the link to the last page. It is inside div.paging-bottom > ul > li with text \">>\"\r\n\tnavigation = soup.find_all(\"div\",id=\"paging-bottom\")\r\n\tif not navigation:\r\n\t\tprint(\"This page is weird. It has no navigation. Aborting\\n\")\r\n\t\treturn result_emails\r\n\r\n\ttxt_elem = navigation[0].ul.find_all(text=\">>\")[0]\r\n\t#link to last page\r\n\tlink = txt_elem.parent\r\n\t#Get its url.. smthg like /ourivesarias-joalharias/134/;jsessionid=67E1932531B84B3E77AAF47A29B263CE\r\n\turl = link['href']\r\n\t#Pick the number of the last page\r\n\tmatch = lp_regex.search(url)\r\n\tif match:\r\n\t\tlast_page = match.group()[0:-2]\r\n\t\tlast_page_i = int(last_page)\r\n\telse:\r\n\t\tprint(\"This category has no navigation to the last page\\n\")\r\n\t\tlast_page_i = first_page\r\n\t\t\r\n\t#Sanity Check\r\n\tif last_page_i < first_page:\r\n\t\tlast_page_i = first_page\r\n\t\t\r\n\tprint(\"Working on category %s\" % initial_url)\r\n\t#Now that we have the last page. Time to iterate on each one and get the emails\r\n\tfor page in xrange( first_page, last_page_i ):\r\n\t\tpage_url = initial_url + str(page) + '/' #This is fragile\r\n\t\tprint(\"Scanning page %d of %d (%s).\" % (page, last_page_i, page_url))\r\n\t\ttry:\r\n\t\t\temails = extract_emails_from_page(bs4.BeautifulSoup( unicode(urlopen(page_url).read(),'utf-8','ignore'), \"html5lib\"))\r\n\t\t\twrite_emails_to_set(emails, result_emails)\r\n\t\t\ttime.sleep(5)\r\n\t\texcept IOError:\r\n\t\t\tprint(\"Coult not fetch url %s. Skipped\\n\" % page_url)\r\n\treturn result_emails","def get_all_pastes_for_account(self, email):\n return self._do_request(urljoin(\"pasteaccount\", email))","def __get_emails(self):\n # This returns a list of Gmail message objects. Documentation can be found at\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\n return self.__service.users().messages().list(userId='me').execute()['messages']","def get_email(self):\n # Scraping the Email Address from Contact Info (email)\n\n # > click on 'Contact info' link on the page\n # self.browser.execute_script(\n # \"(function(){try{for(i in document.getElementsByTagName('a')){let el = document.getElementsByTagName('a')[i]; \"\n # \"if(el.innerHTML.includes('Contact info')){el.click();}}}catch(e){}})()\")\n # time.sleep(loading_pause_time)\n #\n # # > gets email from the 'Contact info' popup\n # try:\n # email = self.browser.execute_script(\n # \"return (function(){try{for (i in document.getElementsByClassName('pv-contact-info__contact-type')){ let \"\n # \"el = \"\n # \"document.getElementsByClassName('pv-contact-info__contact-type')[i]; if(el.className.includes(\"\n # \"'ci-email')){ \"\n # \"return el.children[2].children[0].innerText; } }} catch(e){return '';}})()\")\n #\n # self.browser.execute_script(\"document.getElementsByClassName('artdeco-modal__dismiss')[0].click()\")\n # except:\n # email = 'N/A'","def fetchmail(self):\n mails = []\n\n if self.security == 'SSL/TLS':\n imap = IMAP4_SSL(self.host, self.port)\n else:\n imap = IMAP4(self.host, self.port)\n if self.security == 'STARTTLS':\n imap.starttls()\n imap.login(self.username, self.passwd)\n imap.select(readonly=True)\n\n status, uids = imap.uid('SEARCH', 'UNSEEN')\n\n for uid in uids[0].split():\n status, data = imap.uid('FETCH', uid, '(BODY[HEADER.FIELDS (DATE SUBJECT FROM)])')\n message = self._message_from_data(data)\n mail = Mail(uid, message['FROM'], message['SUBJECT'], message['DATE'])\n mails.append(mail)\n\n imap.close()\n imap.logout()\n\n return mails","def lookup_email(args):\n db = cache.get_default()\n if args.forced:\n db.lookup_email(args.address)\n try:\n info = db.get_email(args.address, nolookup=args.cached)\n print('{!r:} is {:s}valid: {:s}.'.format(info.address, '' if info.is_valid else 'in',\n info.reason))\n except exceptions.CacheMissException:\n exit('{!r:} is not in the cache.'.format(args.address))","def _filter_emails(emails):\n rv = []\n for email in emails:\n if _email_is_valid(email):\n rv.append(email)\n else:\n print 'WARNING: Not including %s (invalid email address)' % email\n return rv","def new_email(self, context, payload):\n\n access_token = util.get_access_token(context['headers'])\n url = util.get_url(context) + f\"messages/{payload['id']}\"\n response = util.rest(\"GET\", url, access_token)\n\n if response.status_code > 400:\n raise Exception(\"Error \", response.text)\n\n email_obj = json.loads(response.text)\n\n return GmailApi.get_email_data(email_obj)","def copyToLdap(user_email):\n user = User.objects.get(email=user_email)\n social = user.social_auth.get(provider='google-oauth2')\n print (\"Get social\")\n print (social)\n domain = user_email.split('@')[1]\n print(domain)\n response = requests.get(\n 'https://www.googleapis.com/admin/directory/v1/users?domain={}'.format(domain),\n params={'access_token': social.extra_data['access_token']}\n )\n print (response.json())\n gappsUsers = response.json().get('users')\n # update records\n confirmedLdapUsers = []\n for gUser in gappsUsers:\n print (gUser.get('primaryEmail'))\n try:\n usr = LdapUser.objects.get(email=gUser.get('primaryEmail'))\n #check if user needs to be deleted\n if gUser['suspended']:\n usr.delete()\n continue\n except LdapUser.DoesNotExist:\n if gUser['suspended']:\n continue\n usr = LdapUser(email=gUser.get('primaryEmail'), password = ''.join(secrets.choice(ALPHABET) for i in range(10)))\n \n usr.group = 1\n usr.uid = gUser['id'] \n usr.first_name = gUser['name']['givenName']\n usr.last_name = gUser['name']['familyName']\n usr.full_name = gUser['name']['fullName']\n usr.username = gUser.get('primaryEmail')\n usr.home_directory = \"/\"\n usr.save()\n\n confirmedLdapUsers.append(usr.email)\n\n #delete users from ldap that are not gApps users\n LdapUser.objects.all().exclude(email__in=confirmedLdapUsers).delete()\n\n return domain","def missing_emails(master_dataframe):\n\tmaster, nine, ten, eleven, twelve = master_dataframe(threshold)\n\tmissing_email = master_dataframe['email'].isnull()\n\n\tl = set()\n\tfor id_num, value in missing_email.iteritems():\n\t\tif value == True:\n\t\t\tl.add(id_num)\n\td = {}\n\tfor i in master.iterrows():\n\t\tid_num = i[0]\n\t\tif id_num in l:\n\t\t\tlast_name = i[1][1]\n\t\t\tfirst_name = i[1][2]\n\t\t\tname = (last_name, first_name)\n\t\t\td[id_num] = name\n\n\tw = csv.writer(open(\"missing_email.csv\", \"w\"))\n\n\tfor key, val in d.items():\n\t\tw.writerow([key,val])","def test_get_many(self, requests_mock, accepts_marketing, emails):\n matcher = requests_mock.post(\n f'{settings.CONSENT_SERVICE_BASE_URL}'\n f'{consent.CONSENT_SERVICE_PERSON_PATH_LOOKUP}',\n json={\n 'results': [\n {\n 'email': email,\n 'consents': [\n CONSENT_SERVICE_EMAIL_CONSENT_TYPE,\n ] if accepts_marketing else [],\n } for email in emails\n ],\n },\n status_code=status.HTTP_200_OK,\n )\n resp = consent.get_many(emails)\n assert resp == {email: accepts_marketing for email in emails}\n\n assert matcher.called_once\n assert matcher.last_request.query == f'limit={len(emails)}'\n assert matcher.last_request.json() == {'emails': emails}","def check_duplicate_email(self, email):\r\n request = self.req_factory.post('unused_url', data={\r\n 'new_email': email,\r\n 'password': 'test',\r\n })\r\n request.user = self.user\r\n self.assertFailedRequest(self.run_request(request), 'An account with this e-mail already exists.')","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n user_id = 'me'\n\n ## get_labels ##\n #print_all_labels(service,user_id)\n #fetch_and_store(service,user_id)\n #apply_rules()","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('gmail', 'v1', http=http)\n\n results = service.users().labels().list(userId='me').execute()\n labels = results.get('labels', [])\n\n FPS = 30\n WINDOWWIDTH = 480\n WINDOWHEIGHT = 320\n\n WHITE = (255, 255, 255)\n RED = (255, 0, 0)\n BLUE = (0, 0, 255)\n GREEN = (0, 255, 0)\n BLACK = (0, 0, 0)\n LIGHTGREEN = (53, 230, 97)\n LIGHTBLUE = (53, 156, 230)\n LIGHTORANGE = (242, 109, 19)\n\n windowBgColor = WHITE\n\n pygame.init()\n FPSCLOCK = pygame.time.Clock()\n DISPLAYSURFACE = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))\n pygame.display.set_caption('PLUTO')\n\n myfont = pygame.font.Font(None, 30)\n label = myfont.render(\"<-- Enter address\", 1, BLACK)\n\n buttonEnterEmail = pygbutton.PygButton((10, 10, 100, 80), 'Enter Email', bgcolor=LIGHTORANGE)\n buttonScan = pygbutton.PygButton((10, 100, 225, 210), 'Scan and Send', bgcolor=LIGHTGREEN, font=myfont)\n buttonReceive = pygbutton.PygButton((245, 100, 225, 210), 'Receive and Print', bgcolor=LIGHTBLUE, font=myfont)\n buttonPrintICR = pygbutton.PygButton((370, 10, 100, 80), 'Letterhead', bgcolor=RED)\n winBgButtons = (buttonEnterEmail, buttonScan, buttonReceive, buttonPrintICR)\n\n allButtons = winBgButtons\n\n userinput = \"\"\n\n while True:\n for event in pygame.event.get(): # event handling loop\n \n if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):\n pygame.quit()\n sys.exit()\n\n if 'click' in buttonReceive.handleEvent(event): #User called for printing of file\n \n idenListCurr = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\n idenListLast = None\n \n #if idenListLast != idenListCurr: #to be used in future with inbox functionality\n\n #msgList = [] #should be a way to do this where only add the new messages\n \n #for each in idenListCurr:\n #iden = each[u'id']\n #mimeMsg = GetMimeMessage(service, 'me', iden)\n \n #msgList.append(mimeMsg)\n\n #idenListLast = idenListCurr\n \n\n #displayInterface(msgList)\n htmlMsg = GetRawMessageHtml(service, 'me', idenListCurr[0][u'id'])\n writeFile(htmlMsg, \"temp\", \"html\")\n \n try:\n pdfkit.from_file(\"/home/pi/git/PlutoTest/temp.html\", \"temp.pdf\") #change to your directory\n except IOError:\n pass\n \n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"Your message will print\")\n printCups.executePrint(\"/home/pi/git/PlutoTest/temp.pdf\") #change to your directory\n os.remove(\"/home/pi/git/PlutoTest/temp.pdf\") #change to your directory\n os.remove(\"/home/pi/git/PlutoTest/temp.html\") #change to your directory\n time.sleep(5)\n \n if 'click' in buttonScan.handleEvent(event):#user called for scanning and sending of file\n scan.executeScan(\"temp\")\n \n message = CreateMessageWithAttachment(\"example.pluto.email@gmail.com\", userinput, \"Hello from Pluto!\", \"Enjoy!\",\n \"/home/pi/git/PlutoTest/\", \"temp.png\") #change to your email, directory\n SendMessage(service, 'me', message)\n \n \n os.remove(\"/home/pi/git/PlutoTest/temp.png\") #change to your directory\n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"Your message has been sent\")\n print(\"sent\")\n time.sleep(5)\n \n if 'click' in buttonEnterEmail.handleEvent(event): #user called to enter e-mail address\n vkeybd = VirtualKeyboard(DISPLAYSURFACE)\n tempInput = vkeybd.run(\"...\")\n if tempInput != \"...\":\n userinput = tempInput\n label = myfont.render(\"To: \" + userinput, 1, BLACK)\n \n if 'click' in buttonPrintICR.handleEvent(event): #user called to print letterhead\n popup = Popup(DISPLAYSURFACE)\n tempInput = popup.run(\"The letterhead will print\")\n printCups.executePrint(\"/home/pi/git/PlutoTest/DemoPaper.png\") #change to your directory\n time.sleep(5)\n\n\n DISPLAYSURFACE.fill(windowBgColor)\n\n for b in allButtons:\n b.draw(DISPLAYSURFACE)\n\n # draw the text onto the surface\n DISPLAYSURFACE.blit(label, (120, 35, 350, 80))\n\n pygame.display.update()\n FPSCLOCK.tick(FPS)","def opt_in(msg_hash):\r\n email, removed = Email.handler.opt_in(msg_hash)\r\n if email and removed:\r\n Email.handler.add_to_queue(None, None, [email], \"reddit.com\",\r\n datetime.datetime.now(g.tz),\r\n '127.0.0.1', Email.Kind.OPTIN)\r\n return email, removed","def api_check_email(request):\n email = request.matchdict['email']\n check_email = RepositorioUsario.check_email(request, email)\n\n return check_email","def test_get_user_by_emailuser_email_get(self):\n pass","def test_skip_blank_emails(self):\n appt_date = datetime.date.today() + datetime.timedelta(days=7) # Default for email\n reminders.Patient.objects.filter(\n pk__in=[self.test_patient.pk, self.other_patient.pk]\n ).update(next_visit=appt_date)\n confirmed = self.create_confirmed_notification(self.test_patient, appt_date)\n blank_contact = self.create_contact(data={'email': ''})\n null_contact = self.create_contact(data={'email': None})\n self.group.contacts.add(blank_contact)\n self.group.contacts.add(null_contact)\n\n self.startRouter()\n self.router.logger.setLevel(logging.DEBUG)\n # run email job\n from afrims.apps.reminders.app import daily_email_callback\n daily_email_callback(self.router)\n\n self.assertEqual(len(mail.outbox), 1)\n message = mail.outbox[0]\n self.assertEqual(len(message.to), 1)\n self.stopRouter()"],"string":"[\n \"def get_emails():\\n\\n # generate the gmail api service\\n service = build_gmail_api_v1()\\n\\n # compute date for one year ago\\n today = date.today()\\n one_year_ago = today - timedelta(days=365.25)\\n start = one_year_ago - timedelta(days=1)\\n end = one_year_ago + timedelta(days=1)\\n start_string = start.strftime(\\\"%Y/%m/%d\\\")\\n end_string = end.strftime(\\\"%Y/%m/%d\\\")\\n query_string = f'after:{start_string} before:{end_string}'\\n\\n # generate the gmail api request (get list of messages from one year ago)\\n request = service.users().messages().list(userId='me', q=query_string)\\n\\n # try to get the api response\\n try:\\n response = request.execute()\\n except HTTPError as e:\\n print('Error response status code : {0}, reason : {1}'.format(\\n e.resp.status, e.error_details))\\n return []\\n\\n # get list of message ids from the api response\\n messages = list(response[\\\"messages\\\"])\\n ids = [message[\\\"id\\\"] for message in messages]\\n\\n # store all emails in a list\\n data_to_display = []\\n\\n # loop through each message id\\n for id in ids:\\n\\n try:\\n # store email data in a dict\\n email = {}\\n\\n # get message data by querying gmail api using message id\\n request = service.users().messages().get(userId='me', id=id)\\n response = request.execute()\\n\\n # get date, subject, from, to, etc from message header\\n headers = list(response[\\\"payload\\\"][\\\"headers\\\"])\\n looking_for = [\\\"Date\\\", \\\"Subject\\\", \\\"From\\\", \\\"To\\\"]\\n for header in headers:\\n if header[\\\"name\\\"] in looking_for:\\n email[header[\\\"name\\\"]] = header[\\\"value\\\"]\\n\\n # try to get message body (base64) from response\\n # the json structure varies a lot so that is why there are no many try/except\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][0][\\\"parts\\\"][0][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][1][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"parts\\\"][0][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n try:\\n base64_message = response[\\\"payload\\\"][\\\"body\\\"][\\\"data\\\"]\\n except (KeyError, TypeError, IndexError) as e:\\n base64_message = \\\"Ti9B\\\"\\n\\n # decode the email body\\n email[\\\"body\\\"] = base64.urlsafe_b64decode(\\n base64_message).decode('utf-8')\\n\\n # populate list with email\\n data_to_display.append(email)\\n\\n except HTTPError as e:\\n print('Error response status code : {0}, reason : {1}'.format(\\n e.resp.status, e.error_details))\\n\\n return data_to_display\",\n \"def getIdeaUrlsFromEmail():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n\\n lists,nextPageToken = ListMessages(service,user_id = 'me',q='from:noreply@tradingview.com')\\n # print (lists)\\n mes,mes_str = GetMimeMessage(service,user_id = 'me',msg_id = lists[0]['id'])\\n # print (mes)\\n j = 0\\n urls = []\\n for part in mes.walk(): \\n j = j + 1 \\n fileName = part.get_filename() \\n contentType = part.get_content_type() \\n mycode=part.get_content_charset(); \\n # 保存附件 \\n if fileName:\\n print ('保存邮件附件……TODO?')\\n elif contentType == 'text/html': #or contentType == 'text/plain' \\n #保存正文 \\n data = part.get_payload(decode=True) \\n content=str(data); \\n # if mycode=='gb2312': \\n # content= mbs_to_utf8(content) \\n #end if \\n # nPos = content.find('降息') \\n # print(\\\"nPos is %d\\\"%(nPos)) \\n # print >> f, data \\n # 正则替换掉所有非 <a></a>的标签 <[^>|a]+>\\n # reg = re.compile('<[^>|a]+>')\\n # print (content)\\n url,title = findIdeaUrlInHtml(content)\\n urls.append((url,title))\\n # print (url,title)\\n # contentTxt = re.compile('<[^>|a]+>').sub('',content)\\n # print (reg.sub('',content))\\n # #end if \\n\\n return urls\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n messageIds = []\\n i = 0\\n nextPageToken = None\\n while (i <= 15):\\n try:\\n response = service.users().messages().list(userId='me', q='after:2016/09/01', maxResults=10000, pageToken=nextPageToken).execute()\\n messages = response.get('messages')\\n nextPageToken = response['nextPageToken']\\n\\n for m in messages:\\n messageIds.append(m['id'])\\n\\n i+=1 \\n except KeyError:\\n break\\n\\n senders = []\\n counter = 0\\n for i in messageIds:\\n data = service.users().messages().get(userId='me', id=i).execute()\\n for d in data['payload']['headers']:\\n if d['name'] == 'Received':\\n print(d['value'][d['value'].find('; ')+1:d['value'].find('(PST)')])\\n if d['name'] == 'From' and 'bounce' not in d['value']:\\n senders.append(d['value'])\\n print(counter, ' ', d['value'])\\n counter += 1\\n break\\n\\n emails = []\\n with open('out.csv', 'wb') as f:\\n writer = csv.writer(f, delimiter=',')\\n for person in set(senders):\\n cleaned = clean_data(person)\\n name = cleaned[0]\\n email = cleaned[1]\\n if email not in emails:\\n emails.append(email)\\n if name != None and email != None:\\n writer.writerow([name, email])\",\n \"def check_for_new_data():\\n SCOPES = ['https://mail.google.com/']\\n creds = None\\n # The file token.json stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.json'):\\n creds = Credentials.from_authorized_user_file('token.json', SCOPES)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file('creds_4.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.json', 'w') as token:\\n token.write(creds.to_json())\\n\\n service = build('gmail', 'v1', credentials=creds)\\n stamp = int(time.time()) - 3600\\n # Call the Gmail API\\n results = service.users().messages().list(userId='me',q=f\\\"from:notify@google.com after:{stamp}\\\").execute()\\n if results[\\\"resultSizeEstimate\\\"] > 0:\\n populate_database()\",\n \"def get_new_mails(self):\\n\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\tself.imap.select(\\\"Inbox\\\")\\n\\t\\t\\tif self.settings.no_remaining == '0' and self.settings.uidnext:\\n\\t\\t\\t\\tif self.settings.uidnext == self.settings.newuidnext:\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t#request all messages between last uidnext and new\\n\\t\\t\\t\\t\\treturn True\\n\\t\\t\\telse:\\n\\t\\t\\t\\tresponse, message = self.imap.uid('search', None, \\\"ALL\\\")\\n\\t\\t\\temail_list = message[0].split()\\n\\t\\telse:\\n\\t\\t\\temail_list = self.pop.list()[1]\\n\\n\\t\\treturn email_list\",\n \"def check_email():\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.ehlo()\\n server.starttls()\\n server.ehlo()\\n server.login(user, password)\\n\\n g = gmail.login(user, password)\\n\\n # Check for unread messages.\\n unread = g.inbox().mail(unread=True)\\n\\n # Submit a job to lint each email sent to editor@proselint.com. Record the\\n # resulting job_ids somewhere (in Redis, I suppose), keyed by a hash of the\\n # email.\\n for u in unread:\\n\\n u.fetch()\\n\\n signature = (u.fr.decode('utf-8') +\\n u.subject.decode('utf-8') +\\n u.body.decode('utf-8'))\\n\\n hash = hashlib.sha256(signature.encode('utf-8')).hexdigest()\\n\\n if user_to in u.to or user_to in u.headers.get('Cc', []):\\n\\n job_id = conn.get(hash)\\n\\n if not job_id:\\n # If the email hasn't been sent for processing, send it.\\n r = requests.post(api_url, data={\\\"text\\\": u.body})\\n conn.set(hash, r.json()[\\\"job_id\\\"])\\n print(\\\"Email {} sent for processing.\\\".format(hash))\\n\\n else:\\n # Otherwise, check whether the results are ready, and if so,\\n # reply with them.\\n r = requests.get(api_url, params={\\\"job_id\\\": job_id})\\n\\n if r.json()[\\\"status\\\"] == \\\"success\\\":\\n\\n reply = quoted(u.body)\\n errors = r.json()['data']['errors']\\n reply += \\\"\\\\r\\\\n\\\\r\\\\n\\\".join([json.dumps(e) for e in errors])\\n\\n msg = MIMEMultipart()\\n msg[\\\"From\\\"] = \\\"{} <{}>\\\".format(name, user)\\n msg[\\\"To\\\"] = u.fr\\n msg[\\\"Subject\\\"] = \\\"Re: \\\" + u.subject\\n\\n if u.headers.get('Message-ID'):\\n msg.add_header(\\\"In-Reply-To\\\", u.headers['Message-ID'])\\n msg.add_header(\\\"References\\\", u.headers['Message-ID'])\\n\\n body = reply + \\\"\\\\r\\\\n\\\\r\\\\n--\\\\r\\\\n\\\" + tagline + \\\"\\\\r\\\\n\\\" + url\\n msg.attach(MIMEText(body, \\\"plain\\\"))\\n\\n text = msg.as_string()\\n server.sendmail(user, u.fr, text)\\n\\n # Mark the email as read.\\n u.read()\\n u.archive()\\n\\n print(\\\"Email {} has been replied to.\\\".format(hash))\",\n \"def main():\\r\\n credentials = get_credentials()\\r\\n http = credentials.authorize(httplib2.Http())\\r\\n service = discovery.build('gmail', 'v1', http=http)\\r\\n\\r\\n response = service.users().messages().list(userId=USER_ID, labelIds=[\\\"SPAM\\\"]).execute()\\r\\n messages = []\\r\\n if 'messages' in response:\\r\\n messages.extend(response['messages'])\\r\\n\\r\\n while 'nextPageToken' in response:\\r\\n page_token = response['nextPageToken']\\r\\n response = service.users().messages().list(userId=USER_ID, labelIds=[\\\"SPAM\\\"], pageToken=page_token).execute()\\r\\n messages.extend(response['messages'])\\r\\n\\r\\n i = 0\\r\\n for message in messages:\\r\\n msg_id = message[\\\"id\\\"]\\r\\n message = service.users().messages().get(userId=USER_ID, id=msg_id).execute()\\r\\n for prop in message[\\\"payload\\\"][\\\"headers\\\"]:\\r\\n if prop[\\\"name\\\"] == \\\"From\\\":\\r\\n print(\\\"ID:\\\", i, \\\"\\\\tFrom:\\\", prop[\\\"value\\\"].encode('ascii','replace'), end=\\\"\\\\t\\\")\\r\\n elif prop[\\\"name\\\"] == \\\"Subject\\\":\\r\\n print(\\\"Subject:\\\", prop[\\\"value\\\"].encode('ascii','replace'))\\r\\n i += 1\\r\\n\\r\\n to_keep = raw_input(\\\"Do you want to keep any emails? [N / 0,1,...] \\\")\\r\\n if \\\",\\\" in to_keep:\\r\\n to_keep = to_keep.split(\\\",\\\")\\r\\n for i in range(len(to_keep)):\\r\\n to_keep[i] = int(to_keep[i])\\r\\n elif to_keep != \\\"N\\\":\\r\\n to_keep = [int(to_keep)]\\r\\n\\r\\n if isinstance(to_keep, list):\\r\\n for i in range(len(to_keep)-1,-1,-1):\\r\\n msg_labels = {'removeLabelIds': [\\\"SPAM\\\"], 'addLabelIds': [\\\"INBOX\\\"]}\\r\\n msg_id = messages[to_keep[i]][\\\"id\\\"]\\r\\n message = service.users().messages().modify(userId=USER_ID, id=msg_id, body=msg_labels).execute()\\r\\n del messages[to_keep[i]]\\r\\n\\r\\n # ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\r\\n # filter0 = service.users().settings().filters().get(userId=USER_ID, id=\\\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\\").execute()\\r\\n # print(filter0)\\r\\n\\r\\n for message in messages:\\r\\n msg_id = message[\\\"id\\\"]\\r\\n # for prop in message[\\\"payload\\\"][\\\"headers\\\"]:\\r\\n # if prop[\\\"name\\\"] == \\\"From\\\":\\r\\n # start_email = prop[\\\"value\\\"].find(\\\"<\\\")\\r\\n # end_email = prop[\\\"value\\\"].find(\\\">\\\", start_email + 1)\\r\\n # email_address = prop[\\\"value\\\"][start_email + 1:end_email]\\r\\n # filter0[\\\"criteria\\\"][\\\"from\\\"] = filter0[\\\"criteria\\\"][\\\"from\\\"] + \\\" OR \\\" + email_address\\r\\n service.users().messages().delete(userId=USER_ID, id=msg_id).execute()\\r\\n\\r\\n # service.users().settings().filters().delete(userId=USER_ID, id=\\\"ANe1BmiDP-rAoJSwkw8T119UU0Z7oisOlVJ4xQ\\\").execute()\\r\\n # service.users().settings().filters().create(userId=USER_ID, body=filter0).execute()\\r\\n print(\\\"All Spam Deleted!\\\")\",\n \"def checkEmail():\\n\\tpop_conn = poplib.POP3_SSL('pop.gmail.com')\\n\\tpop_conn.user('')\\n\\tpop_conn.pass_('')\\n\\t#Get messages from server:\\n\\tmessages = [pop_conn.retr(i) for i in range(1, len(pop_conn.list()[1]) + 1)]\\n\\t# Concat message pieces:\\n\\tmessages = [\\\"\\\\n\\\".join(mssg[1]) for mssg in messages]\\n\\t#Parse message intom an email object:\\n\\tmessages = [parser.Parser().parsestr(mssg) for mssg in messages]\\n\\tflag = 0\\n\\tsweep = None\\n\\tfor message in messages:\\n\\t\\tsubject = message['subject']\\n\\t\\tif subject is None:\\n\\t\\t\\tcontinue\\n\\t\\telif \\\"CommenceSweep:\\\" in subject:\\n\\t\\t\\tstart = subject.find(\\\":\\\")\\n\\t\\t\\tcommand = subject[start+1:]\\n\\t\\t\\tprint command\\n\\t\\t\\tif \\\"Comp\\\"+sys.argv[1] in command:\\n\\t\\t\\t\\tstart = command.find(\\\"-\\\")\\n\\t\\t\\t\\tsweep = command[start+1:]\\n\\t\\t\\t\\tprint sweep\\n\\t\\t\\t\\tpoplist = pop_conn.list()\\n\\t\\t\\t\\tmsglist = poplist[1]\\n\\t\\t\\t\\tfor msgspec in msglist:\\n\\t\\t\\t\\t\\tdelete = int(msgspec.split(' ')[0])\\n\\t\\t\\t\\t\\tpop_conn.dele(delete)\\n\\t\\t\\t\\tflag = 1\\n\\tpop_conn.quit()\\n\\treturn flag, sweep\",\n \"def main(): \\r\\n # Creating a storage.JSON file with authentication details\\r\\n # we are using modify and not readonly, as we will be marking the messages \\r\\n # as Read \\r\\n SCOPES = 'https://www.googleapis.com/auth/gmail.modify' \\r\\n store = file.Storage('storage.json') \\r\\n creds = store.get()\\r\\n if not creds or creds.invalid:\\r\\n flow = client.flow_from_clientsecrets('client_secret.json', SCOPES)\\r\\n creds = tools.run_flow(flow, store)\\r\\n GMAIL = discovery.build('gmail', 'v1', http=creds.authorize(Http()))\\r\\n \\r\\n messages_retrieved=0\\r\\n num_images=0\\r\\n save_dir,search_term = read_prefs() \\r\\n \\r\\n # Getting all the unread messages from Inbox\\r\\n unread_msgs = GMAIL.users().messages().list(userId='me',\\r\\n labelIds=['INBOX', 'UNREAD']).execute()\\r\\n \\r\\n # We get a dictonary. Now reading values for the key 'messages'\\r\\n try:\\r\\n mssg_list = unread_msgs['messages']\\r\\n print (\\\"Total unread messages in inbox: \\\", str(len(mssg_list)))\\r\\n except KeyError: #handle the keyerror on no new messages by exiting\\r\\n print ('No new messages - exiting.')\\r\\n return 0 \\r\\n \\r\\n #loop through the new messages list\\r\\n for i,mssg in enumerate(mssg_list):\\r\\n temp_dict = { }\\r\\n print(\\\"processing message {} of {}\\\".format(i+1,len(mssg_list)))\\r\\n m_id = mssg['id'] # get id of individual message\\r\\n # fetch the message using API\\r\\n message = GMAIL.users().messages().get(userId='me', id=m_id).execute() \\r\\n payld = message['payload'] # get payload of the message \\r\\n header = payld['headers'] # get header of the payload\\r\\n \\r\\n for field in header: # getting the Subject\\r\\n if field['name'] == 'Subject':\\r\\n msg_subject = field['value']\\r\\n temp_dict['Subject'] = msg_subject\\r\\n if field['name'] == 'Date':\\r\\n msg_date = field['value']\\r\\n date_parse = (parser.parse(msg_date))\\r\\n m_date = (date_parse.date())\\r\\n temp_dict['Date'] = str(m_date)\\r\\n else:\\r\\n pass\\r\\n \\r\\n try:\\r\\n\\r\\n # Fetching message body\\r\\n try: #if there is html/data only\\r\\n part_data = payld['body']['data'] # fetching data\\r\\n except: #if there are multiple parts get the html part\\r\\n part_data = payld['parts'][0]['body']['data'] # fetching data from the body\\r\\n # decoding from Base64 to UTF-8\\r\\n clean_one = part_data.replace(\\\"-\\\",\\\"+\\\").replace(\\\"_\\\",\\\"/\\\")\\r\\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) \\r\\n \\r\\n if search_term in temp_dict['Subject']:\\r\\n img_list= soup_process_email(clean_two.decode(\\\"utf8\\\"))\\r\\n print ('{} images found.'.format(len(img_list)))\\r\\n \\r\\n for i in (img_list):\\r\\n print (\\\"downloading: \\\" +i.split('/')[-1])\\r\\n #adding the email date to filepath\\r\\n write_dir=save_dir+temp_dict['Date']+'/'\\r\\n #checking if path exists (and making it if not)\\r\\n ensure_dir(write_dir) \\r\\n if \\\".jpg\\\" in i:\\r\\n # adding filename to write path\\r\\n write_dir=write_dir+\\\"/\\\"+i.split('/')[-1] \\r\\n else:\\r\\n # adding 'mp4' extension to movies and removing leading '?'\\r\\n filename=str(i.split('/')[-1])\\r\\n write_dir=write_dir+\\\"/\\\"+filename[1:]+\\\".mp4\\\" \\r\\n # check if file exists\\r\\n if not does_file_exist(write_dir):\\r\\n time.sleep(1) #rate limiting\\r\\n urllib.request.urlretrieve(i, write_dir) #downloading\\r\\n # num_images+=len(img_list)\\r\\n num_images+=1\\r\\n else:\\r\\n print ('file already downloaded')\\r\\n \\r\\n else:\\r\\n pass \\r\\n messages_retrieved+=1\\r\\n except Exception as e:\\r\\n print (\\\"Unexpected error:\\\", sys.exc_info()[0])\\r\\n print (\\\"Unexpected error:\\\", sys.exc_info()[1])\\r\\n print (\\\"Unexpected error:\\\", sys.exc_info()[2])\\r\\n except:\\r\\n pass \\r\\n \\r\\n #### This will mark the messages as read. when testing is complete\\r\\n GMAIL.users().messages().modify(userId='me', \\r\\n id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \\r\\n \\r\\n \\r\\n print (\\\"Total messages retrieved: \\\", messages_retrieved)\\r\\n print (\\\"Total images retrieved: \\\", num_images)\",\n \"def search_email_advanced(M):\\n print \\\"\\\\n==============================\\\"\\n print \\\"Search emails in advanced mode\\\"\\n print \\\"==============================\\\\n\\\"\\n\\n till_date = 50\\n date_range = datetime.date.today() - datetime.timedelta(till_date)\\n date = date_range.strftime(\\\"%d-%b-%Y\\\")\\n # rv, data = M.uid('search', None, \\\\\\n # '(SENTSINCE {date} FROM \\\"lmxvip@hotmail.com\\\")'.format(date=date))\\n rv, data = M.uid(\\n 'search',\\n None,\\n '(SENTSINCE {date} FROM \\\"cindyyueweiluo@gmail.com\\\")'\\n .format(date=date)\\n )\\n if check_response(rv):\\n return data\\n else:\\n return None\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n user_id = 'me'\\n label_id_one = 'INBOX'\\n label_id_two = 'UNREAD'\\n\\n # Call the Gmail API\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n unread_msgs = service.users().messages().list(userId='me',labelIds=[label_id_one, label_id_two]).execute()\\n mssg_list = unread_msgs['messages']\\n print (\\\"Total unread messages in inbox: \\\", str(len(mssg_list)))\\n final_list = [ ]\\n\\n for mssg in mssg_list:\\n temp_dict = { }\\n m_id = mssg['id'] # get id of individual message\\n message = service.users().messages().get(userId=user_id, id=m_id).execute() # fetch the message using API\\n payld = message['payload'] # get payload of the message \\n headr = payld['headers'] # get header of the payload\\n\\n\\n for one in headr: # getting the Subject\\n if one['name'] == 'Subject':\\n msg_subject = one['value']\\n temp_dict['Subject'] = msg_subject\\n else:\\n pass\\n\\n\\n for two in headr: # getting the date\\n if two['name'] == 'Date':\\n msg_date = two['value']\\n date_parse = (parser.parse(msg_date))\\n m_date = (date_parse.date())\\n temp_dict['Date'] = str(m_date)\\n else:\\n pass\\n\\n for three in headr: # getting the Sender\\n if three['name'] == 'From':\\n msg_from = three['value']\\n temp_dict['Sender'] = msg_from\\n else:\\n pass\\n\\n temp_dict['Snippet'] = message['snippet'] # fetching message snippet\\n\\n\\n try:\\n \\n # Fetching message body\\n mssg_parts = payld['parts'] # fetching the message parts\\n part_one = mssg_parts[0] # fetching first element of the part \\n part_body = part_one['body'] # fetching body of the message\\n part_data = part_body['data'] # fetching data from the body\\n clean_one = part_data.replace(\\\"-\\\",\\\"+\\\") # decoding from Base64 to UTF-8\\n clean_one = clean_one.replace(\\\"_\\\",\\\"/\\\") # decoding from Base64 to UTF-8\\n clean_two = base64.b64decode (bytes(clean_one, 'UTF-8')) # decoding from Base64 to UTF-8\\n soup = BeautifulSoup(clean_two , \\\"lxml\\\" )\\n mssg_body = soup.body()\\n # mssg_body is a readible form of message body\\n # depending on the end user's requirements, it can be further cleaned \\n # using regex, beautiful soup, or any other method\\n temp_dict['Message_body'] = mssg_body\\n\\n except :\\n pass\\n\\n print (temp_dict)\\n final_list.append(temp_dict) # This will create a dictonary item in the final list\\n return final_list[:3]\\n # This will mark the messagea as read\\n #service.users().messages().list(userId=user_id, id=m_id,body={ 'removeLabelIds': ['UNREAD']}).execute() \\n\\n\\n if not labels:\\n print('No labels found.')\\n else:\\n print('Labels:')\\n for label in labels:\\n print(label['name'])\",\n \"def main():\\n \\n ####GET ALL MESSAGES FROM GMAIL###\\n # gmail_usr_name = raw_input(\\\"Enter the gmail user name: \\\\n\\\")\\n # gmail_passwrd = getpass.getpass(\\\"Enter the Gmail password: \\\\n\\\")\\n print(\\\"Please wait while message IDs for Gmail are populated...\\\")\\n gmail_accumulator = Accumulator.Accumulator(GMAIL_PATH, \\\"usr_name\\\", \\\"passwrd\\\",\\n IMAP_PORT, GMAIL_FOLDER)\\n gmail_msg_ids = gmail_accumulator.get_ids()\\n pprint.pprint(gmail_msg_ids)\\n \\n ####GET ALL MESSAGES FROM IMAP###\\n #IMAP2_usr_name = raw_input(\\\"Enter the IMAP2 user name: \\\\n\\\")\\n #IMAP2_passwrd = getpass.getpass(\\\"Enter the IMAP2 password: \\\\n\\\")\\n print(\\\"Please wait while message IDs for IMAP are populated\\\")\\n \\n IMAP2_accumulator = Accumulator.Accumulator(\\\"imap2.lbl.gov\\\", \\\"usr_name\\\", \\\"passwrd\\\",\\n IMAP_PORT, IMAP2_FOLDER)\\n IMAP2_msg_ids = IMAP2_accumulator.get_ids()\\n pprint.pprint(IMAP2_msg_ids)\\n \\n gmail_unique_ids = gmail_accumulator.get_unique_ids()\\n ###FIND THE DIFFERENCES BETWEEN IMAP AND GMAIL.####\\n compare_ids = Comparator.Comparator(IMAP2_msg_ids, gmail_unique_ids)\\n diff_ids = compare_ids.compare()\\n \\n ###FIND THE DUPLICATE IDs FROM IMAP2.###\\n \\n dups = IMAP2_accumulator.get_duplicate_ids()\\n dup_headers = header_info(dups, IMAP2_accumulator)\\n print(\\\"{num_msgs} messages in IMAP2/{fldr}\\\\n\\\".format(num_msgs = IMAP2_accumulator.count_ids(), fldr = IMAP2_accumulator.folder))\\n print(\\\"{num_msgs} messages in GMAIL/{fldr}\\\\n\\\".format(num_msgs = gmail_accumulator.count_ids(), fldr = gmail_accumulator.folder))\\n \\n print(\\\"-------------------------------------------------------------------------------------\\\")\\n print(\\\"There are {num} messages in IMAP2/{fldr1} which are not in Gmail/{fldr2}\\\\n\\\".format(num = len(diff_ids),\\n fldr1 = IMAP2_accumulator.folder,\\n fldr2 = gmail_accumulator.folder))\\n print(\\\"--------------------------------------------------------------------------------------\\\")\\n pprint.pprint(diff_ids)\\n\\n print(\\\"Here is a list of the headers of each message ID which is not in Gmail:\\\\n\\\")\\n headers = header_info(diff_ids, IMAP2_accumulator)\\n\\n ###print a table of the info of the missing messages.###\\n table = prettytable.PrettyTable([\\\"TO\\\", \\\"FROM\\\", \\\"SUBJECT\\\"])\\n table.align[\\\"TO\\\"] = \\\"l\\\"\\n table.padding_width = 1\\n for hdr in headers:\\n table.add_row(hdr)\\n print(table)\\n\\n\\n ###write the output to OUTPUT_FILE.###\\n\\n output_file = open(OUTPUT_FILE, 'w')\\n output_file.write(\\\"\\\\n\\\")\\n output_file.write(\\\"{num_msgs} messages in IMAP2/{fldr}\\\\n\\\".format(num_msgs = IMAP2_accumulator.count_ids(), fldr = IMAP2_accumulator.folder))\\n output_file.write(\\\"{num_msgs} messages in GMAIL/{fldr}\\\\n\\\".format(num_msgs = gmail_accumulator.count_ids(), fldr = gmail_accumulator.folder))\\n output_file.write(\\\"There are {num} messages in IMAP2/{fldr1} which are not in Gmail/{fldr2} \\\\n\\\".format(num = len(diff_ids),\\n fldr1 = IMAP2_accumulator.folder,\\n fldr2 = gmail_accumulator.folder))\\n output_file.write(\\\"Here is a list of the headers of each message ID which is not in Gmail:\\\\n\\\")\\n for ids in diff_ids:\\n output_file.write(str(ids))\\n output_file.write(\\\"\\\\n\\\")\\n output_file.write(\\\"\\\\n\\\")\\n\\n ###OUUTPUT THE TABLE###\\n\\n output_file.write(str(table)) \\n output_file.write(LINE_SEPARATOR)\\n\\n output_file.close()\\n\\n ucb.interact()\",\n \"def test_get_all_email_address(self):\\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\\n email_addr2 = 'test_get_all_email_addr' + '@' + self.email_dom\\n org = 'o=%s' % (self.org_name)\\n people = '%s=%s' % (self.container_attr, self.user_container)\\n uid = '%s=%s' % (self.user_key, self.user_id)\\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\\n dn_info = {self.smtp_address: [email_addr, email_addr2]}\\n expected_result = [(dn, dn_info)] \\n addr = SpokeEmailAddress(self.org_name, self.user_id)\\n addr.create(email_addr)\\n addr.create(email_addr2)\\n result = addr.get()['data']\\n self.assertEqual(result, expected_result)\",\n \"def get_emails(parsed_data):\\n result = []\\n known_values = []\\n contacts = {'registrant_contact': [], 'administrative_contact': [], 'technical_contact': [],\\n 'domain_registrar': []}\\n if 'registrant_contact' in parsed_data:\\n contacts['registrant_contact'].append(parsed_data['registrant_contact'])\\n if 'administrative_contact' in parsed_data:\\n contacts['administrative_contact'].append(parsed_data['administrative_contact'])\\n if 'technical_contact' in parsed_data:\\n contacts['technical_contact'].append(parsed_data['technical_contact'])\\n if 'domain_registrar' in parsed_data:\\n contacts['domain_registrar'].append(parsed_data['domain_registrar'])\\n # parsing email address from contact block\\n\\n for contact, info in contacts.items():\\n if info is not None:\\n d = {'type': 2, 'data': '', 'properties': {}, 'special_properties': {}, 'is_valid': False, 'ref': {}}\\n # properties dictionary\\n is_valid = {}\\n owner = {'owner': '', 'type': 11}\\n organization = {'organization': '', 'type': 11}\\n local_address = {'local_address': '', 'type': 5}\\n domain_name = {'domain_name': '', 'type': 12}\\n properties_list = []\\n special_properties_list = []\\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': ''}})\\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\\n d['ref']['whois_for'] = parsed_data['domain_name']\\n if 'whois_server' in parsed_data:\\n d['ref']['whois_from'] = parsed_data['whois_server']\\n\\n for name in info:\\n if \\\"email_address\\\" in name:\\n if name['email_address'] in known_values:\\n break\\n for feature in name.keys():\\n if feature == \\\"email_address\\\":\\n d['data'] = name['email_address']\\n known_values.append(name['email_address'])\\n\\n if feature == \\\"full_name\\\":\\n owner['owner'] = name['full_name']\\n properties_list.append(owner)\\n\\n if feature == \\\"city_name\\\":\\n organization['organization'] = name['city_name']\\n properties_list.append(organization)\\n\\n d['is_valid'] = ''\\n is_valid = {'isvalid': '', 'type': 0}\\n\\n # prevent from create result if phone number of contact is not available\\n if d['data'] == '':\\n continue\\n try:\\n domain_name['domain_name'] = d['data'].split('@')[1]\\n local_address['local_address'] = d['data'].split('@')[0]\\n properties_list.append(domain_name)\\n properties_list.append(local_address)\\n except:\\n\\n domain_name['domain_name'] = ''\\n local_address['local_address'] = d['data']\\n properties_list.append(domain_name)\\n properties_list.append(local_address)\\n\\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': '', 'label': ''}})\\n d['ref']['label'] = \\\"%s_name\\\" % contact\\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\\n d['ref']['whois_for'] = parsed_data['domain_name']\\n if 'whois_server' in parsed_data:\\n d['ref']['whois_from'] = parsed_data['whois_server']\\n d['properties'] = properties_list\\n special_properties_list.append(is_valid)\\n d['special_properties'] = special_properties_list\\n result.append(d)\\n\\n return result\",\n \"def gmail(screen):\\n\\n\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n\\n\\n if not labels:\\n print('No labels found.')\\n else:\\n if PRINT_CATEGORY: print('Labels:')\\n for label in labels:\\n if PRINT_CATEGORY: print(label['name'])\\n if label['name']=='UNREAD':\\n listMessages = ListMessagesWithLabels(service, 'me', label['name'])\\n nbMessages = len(listMessages)\\n nbMess = 0\\n\\n printTerminal('ENZO! Tu as ['+str(nbMessages)+'] messages non lus.',True)\\n say('ENZO! Tu as: '+str(nbMessages)+' messages non lus.')\\n\\n for message in listMessages:\\n #print(GetMessage(service, 'me', message['id'], False))\\n nbMess+=1\\n ggMessage = GetMessage(service, 'me', message['id'], False)\\n #print(ggMessage)\\n\\n #msg_str = base64.urlsafe_b64decode(ggMessage['raw'].encode('ASCII'))\\n #print(msg_str)\\n\\n for header in ggMessage['payload']['headers']:\\n #print(header)\\n if header['name']=='Subject':\\n #unicode(text,'utf-8')\\n #screen.addstr(0,1,\\\"\\\")\\n if screen:\\n screen.addstr(str(nbMess)+'] '+header['value'])\\n say(header['value'])\\n screen.refresh()\\n else:\\n print(str(nbMess)+'] '+header['value'])\\n say(header['value'])\\n #TTS(header['value'],'french', 50 ,2 )\\n #status=subprocess.call([\\\"espeak\\\",\\\"-s 100 -v fr \\\",header['value']], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\\n\\n #for part in ggMessage['payload']['parts']:\\n # msg = base64.urlsafe_b64decode(part['body']['data'].encode('ASCII'))\\n # print(removehtml(msg))\\n #print(part['body']['data'])\\n #say(part['body']['data'])\\n if len(sys.argv) > 1:\\n if sys.argv[1]=='-t':\\n TTS(ggMessage,'french', 50 ,2 )\\n #for toto in label:\\n # print(toto)\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n\\n lists,nextPageToken = ListMessages(service,user_id = 'me',q='subject:tradingview')\\n # print (lists)\\n mes,mes_str = GetMimeMessage(service,user_id = 'me',msg_id = lists[0]['id'])\\n print (mes)\\n\\n\\n j = 0\\n for part in mes.walk(): \\n j = j + 1 \\n fileName = part.get_filename() \\n contentType = part.get_content_type() \\n mycode=part.get_content_charset(); \\n # 保存附件 \\n if fileName:\\n print ('hhhhhhhhhhhhh')\\n elif contentType == 'text/plain' or contentType == 'text/html': \\n #保存正文 \\n data = part.get_payload(decode=True) \\n content=str(data); \\n # if mycode=='gb2312': \\n # content= mbs_to_utf8(content) \\n #end if \\n # nPos = content.find('降息') \\n # print(\\\"nPos is %d\\\"%(nPos)) \\n # print >> f, data \\n # 正则替换掉所有非 <a></a>的标签 <[^>|a]+>\\n # reg = re.compile('<[^>|a]+>')\\n contentTxt = re.compile('<[^>|a]+>').sub('',content)\\n print (reg.sub('',content))\\n #end if \\n\\n\\n \\n # help(mes)\\n # for i in mes.values():\\n # print (i)\\n # # print (mes[i]);\\n # print (\\\"----------\\\")\\n # print (mes['from'])\\n # print (type (mes))\\n # # print \\n # parsed = Parser().parsestr(mes)\\n # print (parsed)\\n # print (mes)\\n # for i in mes:\\n # print (i)\\n # for item in lists:\\n # mes = GetMimeMessage(service,user_id = 'me',msg_id = item['id'])\\n # # print (mes)\\n # parsed = Parser().parsestr(mes)\\n # print (parsed)\",\n \"def get_email_info_from_all_addressbooks(self, email):\\n logger.info(\\\"Function call: get_email_info_from_all_addressbooks for '{}'\\\".format(email, ))\\n return self.__handle_error('Empty email') if not email else self.__handle_result(self.__send_request('emails/{}'.format(email, )))\",\n \"def emails(self):\\r\\n url = api_base + 'emails/'\\r\\n return json.loads(self.load_url(url))\",\n \"def get_email_addresses(startdate, enddate, user, password):\\n emails = []\\n page = 1\\n more_pages = True\\n\\n while more_pages:\\n response = requests.get(\\n 'https://restapi.surveygizmo.com/v2/survey/{survey}'\\n '/surveyresponse?'\\n 'filter[field][0]=datesubmitted'\\n '&filter[operator][0]=>=&filter[value][0]={start}+0:0:0'\\n '&filter[operator][1]=<&filter[value][1]={end}+0:0:0'\\n '&filter[field][1]=status&filter[operator][1]=='\\n '&filter[value][1]=Complete'\\n '&resultsperpage=500'\\n '&page={page}'\\n '&user:pass={user}:{password}'.format(\\n survey=EMAIL_COLLECTION_SURVEY_ID, start=startdate,\\n end=enddate, page=page, user=user, password=password))\\n\\n results = json.loads(response.content)\\n total_pages = results['total_pages']\\n more_pages = page < total_pages\\n emails = emails + [r['[question(13)]'] for r in results['data']]\\n\\n return emails\",\n \"def main():\\n creds = None\\n # The file token.pickle stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first time.\\n scores = {} # scores is an empty dict already\\n\\n if os.path.getsize('token.pickle') > 0: \\n with open('token.pickle', \\\"rb\\\") as f:\\n unpickler = pickle.Unpickler(f)\\n # if file is not empty scores will be equal\\n # to the value unpickled\\n scores = unpickler.load()\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n creds = pickle.load(token)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.pickle', 'wb') as token:\\n pickle.dump(creds, token)\\n\\n # Starts Gmail V1 with logged in user\\n service = build('gmail', 'v1', credentials=creds)\\n \\n# ================================================================================== \\n\\n\\n # MAIL CHECKHER ================================================================\\n\\n # get mails via gmail api\\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\\n messages = results.get('messages', [])\\n\\n # mail number\\n mail_nr = 0\\n\\n # variabel for how many mails we want to search through\\n message_count = int(input(\\\"Hur många mails vill du söka igenom? \\\"))\\n # if 0 mails are chosen\\n if not messages:\\n print('Inga mail i inkorgen')\\n else:\\n # looks through the email inbox for mails \\\"message_count\\\" amount of times\\n for message in messages[:message_count]:\\n # gets the email id's in full format so we can extraqct information via the gmail api\\n msg = service.users().messages().get(userId='me', id=message['id'], format='full', metadataHeaders=None).execute()\\n # gets the headers of the email in a variable\\n headers = msg[\\\"payload\\\"][\\\"headers\\\"]\\n # from headers gets the sender email, who it was from \\n from_ = [i['value'] for i in headers if i[\\\"name\\\"]==\\\"From\\\"]\\n # from headers gets the subject of the email\\n subject = [i['value'] for i in headers if i[\\\"name\\\"]==\\\"Subject\\\"]\\n # keeps count of the current email\\n mail_nr += 1\\n # if the email is from the security system email print it's information\\n if from_ == ['Python Ormarna <python.ormar@gmail.com>'] or from_ == ['python.ormar@gmail.com']:\\n # gets the email in raw format via gmail api\\n rawmsg = service.users().messages().get(userId=\\\"me\\\", id=message[\\\"id\\\"], format=\\\"raw\\\", metadataHeaders=None).execute()\\n print(\\\"=\\\"*100)\\n print(\\\"\\\\nMail:\\\", mail_nr)\\n print(\\\"Detta mail är från erat säkerhetssystem\\\")\\n # variable the UNIX time of when the email was sent\\n datum = int(msg['internalDate'])\\n datum /= 1000\\n # prints the date and time when the email was revived in local y/m/d/h/m/s\\n print(\\\"Mottaget:\\\", datetime.fromtimestamp(datum).strftime('%Y-%m-%d %H:%M:%S'))\\n print(\\\"Från:\\\", from_)\\n print(\\\"Ämne:\\\", subject)\\n # prints a snippet from the email\\n print(msg['snippet'])\\n print(\\\"\\\\n\\\")\\n else:\\n print(\\\"=\\\"*100)\\n print(\\\"\\\\nMail:\\\", mail_nr)\\n print(\\\"Detta mail är INTE från erat säkerhetssystem\\\\n\\\")\\n time.sleep(1)\\n print(\\\"Inga fler mail hittades\\\")\",\n \"def get_from_email(column_names, start_dates, end_dates, mail_server,\\n account, sender, password):\\n time_flag = None\\n dfs = {test: pd.DataFrame(columns=column_names[test]) \\\\\\n for test in [\\\"covid_ag\\\", \\\"flu_ag\\\"]}\\n start_date = compare_dates(start_dates[\\\"covid_ag\\\"],\\n start_dates[\\\"flu_ag\\\"], \\\"s\\\")\\n end_date = compare_dates(end_dates[\\\"covid_ag\\\"],\\n end_dates[\\\"flu_ag\\\"], \\\"l\\\")\\n\\n with MailBox(mail_server).login(account, password, 'INBOX') as mailbox:\\n for search_date in [start_date + timedelta(days=x)\\n for x in range((end_date - start_date).days + 1)]:\\n for message in mailbox.fetch(A(AND(date=search_date.date(), from_=sender))):\\n for att in message.attachments:\\n name = att.filename\\n\\n # Check the test type\\n if \\\"Sars\\\" in name:\\n test = \\\"covid_ag\\\"\\n elif \\\"Flu\\\" in name:\\n test = \\\"flu_ag\\\"\\n else:\\n continue\\n\\n # Check whether we pull the data from a valid time range\\n whether_in_range = check_whether_date_in_range(\\n search_date, start_dates[test], end_dates[test])\\n if not whether_in_range:\\n continue\\n\\n print(f\\\"Pulling {test} data received on %s\\\"%search_date.date())\\n toread = io.BytesIO()\\n toread.write(att.payload)\\n toread.seek(0) # reset the pointer\\n newdf = pd.read_excel(toread) # now read to dataframe\\n newdf = regulate_column_names(newdf, test)\\n dfs[test] = dfs[test].append(newdf)\\n time_flag = search_date\\n return dfs, time_flag\",\n \"def search_email_by_all(M):\\n print \\\"basic search mode\\\\n\\\"\\n rv, data = M.uid('search', None, 'All')\\n if check_response(rv):\\n return data\\n else:\\n return None\",\n \"def get_emails(print_list, email_dict):\\n\\n email_list = []\\n again = True\\n contact_table = PrettyTable()\\n contact_table.field_names = [\\\"Command\\\", \\\"Advisor Name\\\", \\\"Email\\\"]\\n\\n for row in print_list:\\n contact_table.add_row(row)\\n\\n while again:\\n print(contact_table)\\n pretty_print(email_list, \\\":\\\")\\n pretty_print(\\\"To Add Receiving Emails Enter the corresponding command number\\\", \\\"-\\\")\\n pretty_print(\\\"To Send Mail press any number key:\\\", \\\"-\\\")\\n choice = get_int_input()\\n if choice in email_dict.keys():\\n email_list.append(email_dict[choice])\\n\\n else:\\n if len(email_list) != 0:\\n again = False\\n\\n else:\\n again = True\\n pretty_print(\\\"No Email Added\\\", \\\"-\\\")\\n\\n clear()\\n\\n return email_list\",\n \"def gmail(arg):\\n if not arg:\\n return GOOGLE_MAIL\\n search_content = arg\\n account_num = '0'\\n ret_url = GOOGLE_MAIL + account_num + (('/#search/' + search_content) if search_content else '')\\n print('returning url {}'.format(ret_url))\\n return ret_url\",\n \"def get_email_addresses(survey, startdatetime, enddatetime):\\n token = settings.SURVEYGIZMO_API_TOKEN\\n secret = settings.SURVEYGIZMO_API_TOKEN_SECRET\\n emails = []\\n page = 1\\n more_pages = True\\n survey_id = SURVEYS[survey][\\\"email_collection_survey_id\\\"]\\n dtfmt = \\\"%Y-%m-%d+%H:%M:%S\\\"\\n\\n # Can't do anything without credentials.\\n if token is None or secret is None:\\n return emails\\n\\n while more_pages:\\n response = requests.get(\\n \\\"https://restapi.surveygizmo.com/v2/survey/{survey}\\\"\\n \\\"/surveyresponse?\\\"\\n \\\"filter[field][0]=datesubmitted\\\"\\n \\\"&filter[operator][0]=>=&filter[value][0]={start}\\\"\\n \\\"filter[field][1]=datesubmitted\\\"\\n \\\"&filter[operator][1]=<&filter[value][1]={end}\\\"\\n \\\"&filter[field][2]=status&filter[operator][2]==\\\"\\n \\\"&filter[value][2]=Complete\\\"\\n \\\"&resultsperpage=500\\\"\\n \\\"&page={page}\\\"\\n \\\"&api_token={token}\\\"\\n \\\"&api_token_secret={secret}\\\".format(\\n survey=survey_id,\\n start=startdatetime.strftime(dtfmt),\\n end=enddatetime.strftime(dtfmt),\\n page=page,\\n token=token,\\n secret=secret,\\n ),\\n timeout=300,\\n )\\n\\n results = json.loads(response.content)\\n total_pages = results.get(\\\"total_pages\\\", 1)\\n more_pages = page < total_pages\\n emails = emails + [r[\\\"[question(13)]\\\"] for r in results[\\\"data\\\"]]\\n page += 1\\n\\n valid_emails = []\\n for email in emails:\\n try:\\n validate_email(email)\\n except ValidationError:\\n pass\\n else:\\n valid_emails.append(email)\\n\\n return valid_emails\",\n \"def _get_unread_emails(conn):\\n pattern = re.compile('^\\\\d+\\\\ \\\\(ENVELOPE\\\\ \\\\(\\\"(.*?)\\\"\\\\ \\\"(.*?)\\\"\\\\ \\\\(\\\\(\\\"(.*?)\\\"\\\\ .*?\\\\ \\\"(.*?)\\\"\\\\ \\\"(.*?)\\\"\\\\)\\\\).*$')\",\n \"def test_get_missing_email_account(self):\\n acc = SpokeEmailAccount(self.org_name, self.user_id)\\n email_addr = 'missing@' + self.email_dom\\n result = acc.get(email_addr)['data']\\n expected_result = []\\n self.assertEqual(result, expected_result)\",\n \"def audit_emails_in_metadata(self):\\n\\n # Iterate over commits....\\n disallowed_domains = [\\\"localhost\\\", \\\"localhost.localdomain\\\", \\\"(none)\\\", \\\"bombardier.com\\\", \\\"rail.bombardier.com\\\"]\\n for commit in self.repository.commits.values():\\n for email_address in [ commit.committer_email, commit.author_email ]:\\n # Extract the email address, and reject them if extraction fails....\\n extraction = re.match(\\\"^(\\\\S+)@(\\\\S+)$\\\", email_address)\\n if not extraction:\\n self.__log_failure(commit.sha1, \\\"Seemingly invalid email address: \\\" + email_address)\\n continue\\n\\n # Don't allow domains which are disallowed...\\n domain = extraction.group(2)\\n if domain in disallowed_domains:\\n self.__log_failure(commit.sha1, \\\"Email address using a blocked domain: \\\" + email_address)\\n continue\\n\\n # Ensure they have a valid MX/A entry in DNS....\\n try:\\n dns.resolver.query(domain, \\\"MX\\\")\\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel):\\n try:\\n dns.resolver.query(domain, \\\"A\\\")\\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel, dns.resolver.NXDOMAIN):\\n self.__log_failure(commit.sha1, \\\"Email address has an invalid domain : \\\" + email_address)\\n except (dns.resolver.NXDOMAIN, dns.resolver.NoNameservers):\\n self.__log_failure(commit.sha1, \\\"Email address has an invalid domain : \\\" + email_address)\",\n \"def test_get_email_address(self):\\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\\n org = 'o=%s' % (self.org_name)\\n people = '%s=%s' % (self.container_attr, self.user_container)\\n uid = '%s=%s' % (self.user_key, self.user_id)\\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\\n dn_info = {self.smtp_address: [email_addr]}\\n expected_result = [(dn, dn_info)] \\n addr = SpokeEmailAddress(self.org_name, self.user_id)\\n addr.create(email_addr)\\n result = addr.get(email_addr)['data']\\n self.assertEqual(result, expected_result)\",\n \"def test_get_email_account(self):\\n email_addr = self.user_id + '@' + self.email_dom\\n org = '%s=%s' % (self.org_attr, self.org_name)\\n people = '%s=%s' % (self.container_attr, self.user_container)\\n uid = '%s=%s' % (self.user_key, self.user_id)\\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\\n dn_info = {self.imap_enable: ['TRUE'],\\n self.imap_mailbox: [self.user_id],\\n self.imap_domain: [self.email_dom],\\n self.imap_partition: [self.imap_partition_def],\\n self.smtp_destination: [email_addr],\\n self.smtp_enable: ['TRUE'],\\n self.smtp_pri_address: [email_addr]\\n }\\n expected_result = [(dn, dn_info)] \\n acc = SpokeEmailAccount(self.org_name, self.user_id)\\n result = acc.get(self.email_addr)['data']\\n self.assertEqual(result, expected_result)\",\n \"def update_from_emails(self, emails):\\n # Now add contributors using cache (new GitHub contributors) with known email or orcid that isn't present\\n for email in emails:\\n if email not in self.email_lookup:\\n bot.info(f\\\" Updating with new added email: {email}\\\")\\n entry = {\\\"@type\\\": \\\"Person\\\", \\\"email\\\": email}\\n self.lookup.append(entry)\",\n \"def getEmail(self, data):\\r\\n\\t\\tprint('test')\\r\\n\\t\\t# Empty array to hold unique emails\\r\\n\\t\\tno_dp_email = []\\r\\n\\r\\n\\t\\t# Loop through each row in the dataframe...\\r\\n\\t\\tfor row in data.itertuples():\\r\\n\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t# Parse through the row's keywords string for emails...\\r\\n\\t\\t\\temails = re.findall(\\\"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Za-z]{2,4}\\\", row.keywords)\\r\\n\\t\\t\\tprint(emails)\\r\\n\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t# For each email in the array...\\r\\n\\t\\t\\tfor email in emails:\\r\\n\\t\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t\\temail = str(email)\\r\\n\\r\\n\\t\\t\\t\\t# Append this email onto the array if it is not a repeat\\r\\n\\t\\t\\t\\tif email not in no_dp_email:\\r\\n\\t\\t\\t\\t\\tprint('test')\\r\\n\\r\\n\\t\\t\\t\\t\\tno_dp_email.append(email)\\r\\n\\t\\t\\r\\n\\t\\t# return array of unique emails\\r\\n\\t\\treturn no_dp_email\",\n \"def main():\\n token = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-token.json'\\n credential = 'C:/Users/asif.rouf/PycharmProjects/pythonProject/AX_Admin_portal/Test/utils/google-api-credentials.json'\\n creds = None\\n # The file token.json stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n if os.path.exists(token):\\n creds = Credentials.from_authorized_user_file(token, SCOPES)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n credential, SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n # with open('token.json', 'w') as token:\\n # token.write(creds.to_json())\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n # # Call the Gmail API\\n # results = service.users().labels().list(userId='me').execute()\\n # labels = results.get('labels', [])\\n #\\n # if not labels:\\n # print('No labels found.')\\n # else:\\n # print('Labels:')\\n # for label in labels:\\n # print(label['name'])\\n\\n # Call the Gmail API to fetch INBOX\\n results = service.users().messages().list(userId='me', labelIds=['INBOX']).execute()\\n messages = results.get('messages', [])\\n # message1 = messages[0]\\n # print(message1)\\n message1 = {'id': '17a5ca5f5f4bd0aa', 'threadId': '17a5b1bb861b3bc2'}\\n message1 = {'id': '17a5cbc54c546465', 'threadId': '17a5b1bb861b3bc2'}\\n\\n # message1 = {'id': '17a5b852afe04a52', 'threadId': '17a50c997c059e68'}\\n print(messages)\\n print(message1)\\n\\n if not messages:\\n print(\\\"No messages found.\\\")\\n else:\\n print(\\\"Message snippets:\\\")\\n # for message in messages:\\n # msg = service.users().messages().get(userId='me', id=message['id']).execute()\\n # print(messages)\\n # print(msg['snippet'])\\n\\n # msg = service.users().messages().get(userId='me', id=message1['id']).execute()\\n # print(msg['snippet'])\\n ###############################\\n msg = service.users().messages().get(userId='me', id=message1['id'], format='raw').execute()\\n msg_str = base64.urlsafe_b64decode(msg['raw'].encode('ASCII'))\\n mime_msg = email.message_from_bytes(msg_str)\\n print(msg['snippet'])\\n print(mime_msg)\\n print(mime_msg['Date'])\\n print(mime_msg['From'])\\n print(mime_msg['To'])\\n print(mime_msg['Subject'])\\n #\\n # print(datetime.utcnow())\\n\\n ######################################################\\n # msg = service.users().messages().get(userId='me', id=message1['id'], format='full').execute()\\n # # parts can be the message body, or attachments\\n # payload = msg['payload']\\n # headers = payload.get(\\\"headers\\\")\\n # parts = payload.get(\\\"parts\\\")\\n # # print(payload)\\n # # print(parts)\\n # # print(headers)\\n # for header in headers:\\n # print(header['name'])\\n # print(header['value'])\\n #\\n ######################################################\\n msg = service.users().messages().get(userId='me', id=message1['id']).execute()\\n\\n # Use try-except to avoid any Errors\\n try:\\n # Get value of 'payload' from dictionary 'txt'\\n payload = msg['payload']\\n headers = payload['headers']\\n subject = ''\\n sender = ''\\n\\n # Look for Subject and Sender Email in the headers\\n for d in headers:\\n if d['name'] == 'Subject':\\n subject = d['value']\\n if d['name'] == 'From':\\n sender = d['value']\\n # The Body of the message is in Encrypted format. So, we have to decode it.\\n # Get the data and decode it with base 64 decoder.\\n parts = payload.get('parts')[0]\\n data = parts['body']['data']\\n data = data.replace(\\\"-\\\", \\\"+\\\").replace(\\\"_\\\", \\\"/\\\")\\n decoded_data = base64.b64decode(data)\\n\\n # Now, the data obtained is in lxml. So, we will parse\\n # it with BeautifulSoup library\\n soup = BeautifulSoup(decoded_data, \\\"lxml\\\")\\n body = soup.body()\\n\\n # Printing the subject, sender's email and message\\n print(\\\"Subject: \\\", subject)\\n print(\\\"From: \\\", sender)\\n print(\\\"Message: \\\", body)\\n # for link in soup.find_all('a', href=True):\\n # print(link['href'])\\n link = soup.find('a', href=True)\\n print(link['href'])\\n except:\\n pass\",\n \"def test_get_all_email_domains(self):\\n email_dom2 = 'testgetall.com'\\n org = 'o=%s' % (self.org_name)\\n dn = '%s,%s' % (org, self.base_dn)\\n dn_info = {'aenetPostfixDomain': [self.email_dom, email_dom2]}\\n expected_result = [(dn, dn_info)] \\n domain = SpokeEmailDomain(self.org_name)\\n domain.create(email_dom2)\\n result = domain.get()['data']\\n self.assertEqual(result, expected_result)\",\n \"def ValidateEmails(contacts):\\n contacts = [c.strip() for c in contacts.strip().split(',') if c.strip()]\\n contact_emails = [utils.GetEmailAddress(c) for c in contacts]\\n try:\\n user_service = service_factory.GetUserInfoService()\\n person_hash = user_service.GetUserInfoMulti(contact_emails)\\n # Suppress pylint catch Exception\\n # pylint: disable-msg=W0703\\n except errors.ServiceCriticalError:\\n person_hash = {}\\n\\n res = []\\n for contact, contact_email in zip(contacts, contact_emails):\\n item = {'input': contact, 'email': contact_email, 'name': contact}\\n if contact_email in person_hash:\\n item['name'] = person_hash[contact_email].name\\n res.append(item)\\n\\n return res\",\n \"def email_all():\\n\\tSubscribtion = session.query(email).all()\\n\\treturn subscribtion_object\",\n \"def send(self):\\n msg_sent = []\\n subs = mongo.db.subscribers\\n bill_extractor = ExtractBills()\\n \\n # Do not need the object ID\\n same_interval = subs.find({\\\"interval\\\":self.interval}, {'_id':0})\\n \\n for each in same_interval:\\n email = each['email']\\n tags = each['search_tags']\\n state = each['state']\\n chamber = each['chamber']\\n print(email, tags)\\n\\n msg_for_rcpnt = bill_extractor.getBill(state, chamber, tags)\\n #all_candidates.append((email, msg_for_rcpnt))\\n \\n #try:\\n # msg_body = \\\"hello world\\\"\\n # msg_body = render_template('mail_card.html')\\n # msg = Message(msg_body,\\n # sender=\\\"mssshaown@gmail.com\\\",\\n # recipients=email)\\n # mail.send(msg) \\n # msg_sent.append((email, \\\"Success\\\"))\\n #except Exception as e:\\n # msg_sent.append((email, str(e)))\\n #return msg_sent\\n return msg_for_rcpnt\",\n \"def scrape_emails(webpage):\\n emails = []\\n html = requests.get(webpage)\\n email_regex = re.compile(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\\\.[a-zA-Z]+')\\n emails = email_regex.findall(html.text)\\n return emails\",\n \"def get_group_of_emails(M):\\n print \\\"Try to access group of emails\\\"\\n data = search_email_advanced(M)\\n if data is None:\\n return\\n # print \\\"Got data as \\\", data\\n ids = data[0]\\n id_list = ids.split()\\n for id_num in id_list:\\n rv, data = M.uid('fetch', id_num, \\\"(RFC822)\\\")\\n if rv != \\\"OK\\\":\\n print \\\"Error getting message\\\"\\n return\\n # get raw text of the whole email\\n raw_email = data[0][1]\\n content = email.message_from_string(raw_email)\\n # print raw_email\\n p = EmailParser()\\n # print sender and receivers\\n print \\\"To: \\\", content['To'], \\\"\\\\n\\\"\\n print \\\"From: \\\", email.utils.parseaddr(content['From']), \\\"\\\\n\\\"\\n print \\\"Date: \\\", content['Date'], \\\"\\\\n\\\"\\n print \\\"Subject: \\\", p.parsestr(raw_email).get('Subject'), \\\\\\n \\\"\\\\n\\\"\\n result = parse_content(content)\\n # print results\\n printData(result)\",\n \"def get_email_addresses(r):\\n email_match = re.findall(r'[\\\\w.-]+@[\\\\w.-]+.\\\\w+', r)\\n email_list = []\\n if email_match:\\n for match in email_match:\\n if match not in email_list:\\n email_list.append(match)\\n email_list = set(email_list)\\n return email_list\",\n \"def go():\\n # Authenticate\\n print('****************** Authenticate ******************')\\n\\n creds = None\\n\\n if os.path.exists('token.pickle'):\\n with open('token.pickle', 'rb') as token:\\n print('****************** Load Token ******************')\\n\\n creds = pickle.load(token)\\n\\n if not creds or not creds.valid:\\n print('****************** Credentials ******************')\\n\\n if creds and creds.expired and creds.refresh_token:\\n print('****************** Refresh Credentials ******************')\\n\\n creds.refresh(Request())\\n else:\\n print('****************** Load Credentials ******************')\\n\\n flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n\\n with open('token.pickle', 'wb') as token:\\n print('****************** Dump Token ******************')\\n\\n pickle.dump(creds, token)\\n\\n print('****************** Load Service ******************')\\n\\n service = build('gmail', 'v1', credentials=creds)\\n\\n # Set Date Range\\n print('****************** Set Date Range ******************')\\n \\n start_datetime = datetime.today() - timedelta(days=2)\\n end_datetime = datetime.today() + timedelta(days=2)\\n\\n start_date = start_datetime.strftime(\\\"%Y/%m/%d\\\")\\n end_date = end_datetime.strftime(\\\"%Y/%m/%d\\\")\\n\\n print(start_date)\\n print(end_date)\\n\\n # Set Query\\n print('****************** Set Query ******************')\\n\\n user_id = 'me'\\n full = 'full'\\n query = 'after:' + start_date + ' before:' + end_date + ' subject:Your Single Transaction Alert from Chase'\\n\\n print(query)\\n\\n # List Messages (All Pages)\\n print('****************** Run Query ******************')\\n\\n response = service.users().messages().list(userId=user_id, q=query).execute()\\n\\n messages_all_pages = []\\n\\n if 'messages' in response:\\n messages_all_pages.extend(response['messages'])\\n\\n while 'nextPageToken' in response:\\n page_token = response['nextPageToken']\\n response = service.users().messages().list(userId=user_id, q=query, pageToken=page_token).execute()\\n messages_all_pages.extend(response['messages'])\\n\\n messages = messages_all_pages\\n\\n # Find Transactions in Message List\\n if not messages:\\n print('No messages found...')\\n else:\\n for message in messages:\\n queue_id = message['id']\\n\\n # Get Message\\n this_message = service.users().messages().get(userId=user_id, id=queue_id, format=full).execute()\\n\\n # Set Message\\n message_body = this_message['payload']['body']['data']\\n message_html = base64.urlsafe_b64decode(message_body)\\n message_text = message_html.decode('utf-8').replace('($USD) ', '')\\n\\n # Set Transaction Date\\n date_message = int(this_message['internalDate'])\\n date_object = (date_message / 1000)\\n transaction_date = datetime.fromtimestamp(date_object).strftime(\\\"%Y-%m-%d\\\")\\n\\n # Set Amount\\n amount = re.search('A charge of (.+?) at', message_text).group(1)\\n\\n # Set Description\\n description = re.search('at (.+?) has', message_text).group(1)\\n\\n # Build Transaction\\n transaction = {\\n 'QueueID': queue_id,\\n 'TransactionTypeID': 2,\\n 'TransactionDT': transaction_date,\\n 'Description': description,\\n 'Amount': amount,\\n 'BudgetCategoryID': '103',\\n 'TransactionNumber': '',\\n 'Note': 'CC'\\n }\\n\\n print('****************** Transaction Found ******************')\\n print(transaction)\\n\\n # Send to Queue\\n response_data = requests.post(url=BUDGET_API, data=transaction)\\n\\n result = response_data.text\\n\\n if result == '1':\\n print('****************** Transaction Queued ******************')\",\n \"def test_06_get_person_by_email(self):\\n p1 = Person.query.first()\\n p1_data = p1.wrap()\\n p1_email = p1_data[\\\"email\\\"]\\n q_string = \\\"?email={}\\\".format(p1_email[2:10]) # TODO - verify the length of email before slicing\\n rv = self.app.get('persons', query_string=q_string)\\n data = json.loads(rv.data)\\n self.assertEqual(data[\\\"count\\\"], 1)\",\n \"def fetch_all(self):\\n emails = []\\n res, messages = self._mailconn.search(None, 'ALL')\\n if res == 'OK':\\n for msg in messages[0].split():\\n try:\\n res, data = self._mailconn.fetch(msg.decode('utf-8'), '(RFC822)')\\n except Exception as error:\\n self.close_mail_connection()\\n print('No email to read: '+error)\\n exit()\\n \\n msg = email.message_from_string((data[0][1]).decode('utf-8'))\\n if not isinstance(msg, str):\\n if self.is_sender_in_whitelist(msg['From']):\\n emails.append(msg)\\n\\n return emails\",\n \"def test_get_missing_email_address(self):\\n addr = SpokeEmailAddress(self.org_name, self.user_id)\\n email_addr = 'missing@' + self.email_dom\\n result = addr.get(email_addr)['data']\\n expected_result = []\\n self.assertEqual(result, expected_result)\",\n \"def _print_basic_email_information(emails, conn):\\n for mid in emails:\\n (res, data) = conn.fetch(mid, '(ENVELOPE)')\\n headers = pattern.match(data[0])\\n print 'Date: %s' % headers.group(1)\\n print 'Subject: %s' % headers.group(2)\\n print 'From: %s <%s@%s>' % (headers.group(3), headers.group(4), headers.group(5))\\n print\",\n \"def check_for_subscribers(mail, login_info):\\n ADDRESS, PASSWORD = login_info\\n\\n try:\\n mail.select('inbox')\\n data = mail.search(None, 'ALL') \\n except:\\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\\n mail.login(ADDRESS, PASSWORD)\\n mail.select('inbox')\\n data = mail.search(None, 'ALL')\\n \\n mail_ids = data[1]\\n id_list = mail_ids[0].split() \\n\\n if not id_list:\\n return []\\n\\n first_email_id = int(id_list[0])\\n latest_email_id = int(id_list[-1])\\n\\n subscribers = []\\n\\n for i in range(latest_email_id, first_email_id-1, -1):\\n data = mail.fetch(str(i), '(RFC822)')\\n for response_part in data:\\n arr = response_part[0]\\n if isinstance(arr, tuple):\\n msg = email.message_from_string(str(arr[1],'utf-8'))\\n email_from = msg['from']\\n subscribers.append(email_from)\\n\\n return subscribers\",\n \"def search_email_by_time(M):\\n print \\\"search mail by time\\\\n\\\"\\n date = (datetime.date.today() - datetime.timedelta(1)).strftime(\\\"%d-%b-%Y\\\")\\n rv, data = M.uid('search', None, '(SENTSINCE {date})'.format(date=date))\\n if check_response(rv):\\n return data\\n else:\\n return None\",\n \"def isEmailUsed(self, email):\\n\\n\\t\\ttestq = {\\\"email\\\": email};\\n\\t\\ttest_result = self.db.request(\\\"getOne\\\", testq);\\n\\n\\t\\tif test_result:\\n\\t\\t\\treturn True;\\n\\t\\telse:\\n\\t\\t\\treturn False;\",\n \"def find_expired_email(mails):\\n if not mails:\\n return []\\n\\n # get a copy of mails sort by datetime in desc order first\\n mails_date = sorted(mails, key=lambda m:m.datetime, reverse=True)\\n last7mails = mails_date[:7]\\n bmail = last7mails[-1]\\n # year|month|date => mail.mid\\n reserv_mails = { m.datetime:m.mid for m in last7mails }\\n def reserv_m(key, mail):\\n if not reserv_mails.has_key(key):\\n reserv_mails[key] = mail.mid\\n\\n for mail in mails_date[7:]:\\n if mail.datetime.year < bmail.datetime.year:\\n # mails sent in the last years, keep the newest mail per year\\n reserv_m(mail.datetime.year, mail)\\n elif mail.datetime.year == bmail.datetime.year and \\\\\\n mail.datetime.month < bmail.datetime.month:\\n # mails sent in the last months, keep the newest mail per month\\n reserv_m(mail.datetime.month, mail)\\n\\n reserv_mids = dict.fromkeys(reserv_mails.values())\\n return [m for m in mails if m.mid not in reserv_mids]\",\n \"def generate_email_address(count: int = 1) -> list:\\n\\n pass\",\n \"def fetch_mailbox((mailbox, host, user, passwd)):\\r\\n\\r\\n global text, attachments\\r\\n\\r\\n ## login to the pop3 server ==============================\\r\\n print\\r\\n print \\\"###### Connecting to %s\\\" % host\\r\\n M = poplib.POP3(host)\\r\\n M.set_debuglevel(1)\\r\\n M.user(user)\\r\\n M.pass_(getpass.getpass())\\r\\n\\r\\n ## create the mailbox and attachments directories if required\\r\\n if not os.path.exists (mailboxdir):\\r\\n print \\\"Creating Directory %s\\\", mailboxdir\\r\\n os.mkdir (mailboxdir)\\r\\n\\r\\n att_dir = \\\"%s\\\\\\\\att_%s\\\" % (mailboxdir, mailbox)\\r\\n if not os.path.exists (att_dir):\\r\\n print \\\"Creating Directory %s\\\", att_dir\\r\\n os.mkdir (att_dir)\\r\\n\\r\\n \\r\\n ## get list of uidls in the mailbox file =================\\r\\n uidls = get_mailbox_uidls(mailbox)\\r\\n\\r\\n ## get number of messages ================================\\r\\n numMessages = len(M.list()[1])\\r\\n print \\\"There are %d messages on the server\\\" % numMessages\\r\\n\\r\\n\\r\\n ## get uidls from server and compare with the uidls in the\\r\\n ## mailbox ===============================================\\r\\n uidls_srv = M.uidl()\\r\\n list = uidls_srv[1]\\r\\n fetchlist = []\\r\\n for item in list:\\r\\n msgno, uidl = item.split(' ')\\r\\n msgno = int(msgno)\\r\\n if not uidl in uidls:\\r\\n print \\\"Found new message: (%d, %s)\\\" % (msgno, uidl)\\r\\n fetchlist.append(msgno)\\r\\n\\r\\n print \\\"There are %d new messages on the server\\\" % len(fetchlist)\\r\\n\\r\\n alltext = \\\"\\\" ## this variable contains the mbox contents\\r\\n\\r\\n ## go over all of the emails =============================\\r\\n for i in fetchlist:\\r\\n\\r\\n flatmsg = \\\"\\\"\\r\\n\\r\\n ## retreive message\\r\\n# for line in M.retr(i+1)[1]:\\r\\n for line in M.retr(i)[1]:\\r\\n flatmsg += line + \\\"\\\\r\\\\n\\\"\\r\\n\\r\\n ## parse message\\r\\n msg = email.message_from_string (flatmsg)\\r\\n\\r\\n ## handle Email.message object\\r\\n title = handleMsg(mailbox, msg)\\r\\n\\r\\n\\r\\n msgtext = \\\"%s\\\\n%s* UIDL: %s\\\\n%s\\\\n\\\\n\\\" % (''.center(70,'#'), title, uidl, text)\\r\\n if not attachments == \\\"\\\":\\r\\n msgtext += \\\"#### Attachments:\\\\n%s\\\" % attachments\\r\\n\\r\\n alltext = msgtext.replace('\\\\r\\\\n','\\\\n') + alltext\\r\\n\\r\\n ## add 'alltext' to the beginning of the mailbox file ====\\r\\n mboxfile = \\\"%s\\\\\\\\%s.mbx\\\" % (mailboxdir, mailbox)\\r\\n contents = \\\"\\\"\\r\\n if os.path.exists(mboxfile):\\r\\n mbox = open(mboxfile, \\\"rt\\\")\\r\\n contents = mbox.read()\\r\\n mbox.close()\\r\\n\\r\\n mbox = open(mboxfile, \\\"wt\\\")\\r\\n mbox.write (alltext)\\r\\n if contents != \\\"\\\":\\r\\n mbox.write (contents)\\r\\n\\r\\n mbox.close()\\r\\n\\r\\n return len(fetchlist)\",\n \"def get_duplicate_emails():\\n UserModel = get_user_model()\\n users = UserModel.objects.all()\\n emails_seen = {}\\n duplicate_emails = []\\n for user in users:\\n email = user.email.lower()\\n if email in emails_seen:\\n duplicate_emails.append(email)\\n else:\\n emails_seen[email] = True\\n return duplicate_emails\",\n \"def getIssuesEmail(self):\\r\\n base_url = \\\"http://beta.boost.org/development/tests/\\\"\\r\\n base_url += self.branch\\r\\n base_url += \\\"/developer/\\\";\\r\\n got_issues = False\\r\\n\\r\\n # Ping the server by looking for an HTML file\\r\\n print \\\"Pinging the server to initiate extraction...\\\"\\r\\n ping_url = base_url + \\\"issues.html\\\"\\r\\n os.system('curl -O ' + ping_url)\\r\\n os.system('rm -f issues.html')\\r\\n \\r\\n for x in range(30):\\r\\n # Update issues-email.txt\\r\\n url = base_url + \\\"issues-email.txt\\\"\\r\\n print 'Retrieving issues email from ' + url\\r\\n os.system('rm -f issues-email.txt')\\r\\n os.system('curl -O ' + url)\\r\\n\\r\\n if self.parseIssuesEmail():\\r\\n return True\\r\\n\\r\\n print 'Failed to fetch issues email. '\\r\\n time.sleep (30)\\r\\n\\r\\n return False\",\n \"def get_messages(self):\\n\\t\\tif not self.check_mails():\\n\\t\\t\\treturn # nothing to do\\n\\n\\t\\tfrappe.db.commit()\\n\\n\\t\\ttry:\\n\\t\\t\\t# track if errors arised\\n\\t\\t\\tself.errors = False\\n\\t\\t\\tself.latest_messages = []\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\tuid_validity = self.get_status()\\n\\t\\t\\telse:\\n\\t\\t\\t\\temail_list = self.get_new_mails()\\n\\n\\n\\t\\t\\t# size limits\\n\\t\\t\\tself.total_size = 0\\n\\t\\t\\tself.max_email_size = cint(frappe.local.conf.get(\\\"max_email_size\\\"))\\n\\t\\t\\tself.max_total_size = 5 * self.max_email_size\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\t#try:\\n\\t\\t\\t\\tif self.check_uid_validity(uid_validity):\\n\\t\\t\\t\\t\\temail_list = self.get_new_mails()\\n\\t\\t\\t\\t\\tif email_list:\\n\\t\\t\\t\\t\\t\\tself.get_imap_messages(email_list)\\n\\t\\t\\t\\t\\tself.sync_flags()\\n\\t\\t\\t\\t\\tself.get_seen()\\n\\t\\t\\t\\t\\tself.push_deleted()\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tpass\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnum = num_copy = len(email_list)\\n\\n\\t\\t\\t\\t# WARNING: Hard coded max no. of messages to be popped\\n\\t\\t\\t\\tif num > 20: num = 20 #20\\n\\n\\t\\t\\t\\tfor i, message_meta in enumerate(email_list):\\n\\t\\t\\t\\t\\t# do not pull more than NUM emails\\n\\t\\t\\t\\t\\tif (i+1) > num:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tself.retrieve_message(message_meta, i+1)\\n\\t\\t\\t\\t\\texcept (TotalSizeExceededError, EmailTimeoutError, LoginLimitExceeded):\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t# WARNING: Mark as read - message number 101 onwards from the pop list\\n\\t\\t\\t\\t# This is to avoid having too many messages entering the system\\n\\t\\t\\t\\tnum = num_copy\\n\\t\\t\\t\\tif not cint(self.settings.use_imap):\\n\\t\\t\\t\\t\\tif num > 100 and not self.errors:\\n\\t\\t\\t\\t\\t\\tfor m in xrange(101, num+1):\\n\\t\\t\\t\\t\\t\\t\\tself.pop.dele(m)\\n\\n\\t\\texcept Exception, e:\\n\\t\\t\\tif self.has_login_limit_exceeded(e):\\n\\t\\t\\t\\tpass\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise\\n\\n\\t\\tfinally:\\n\\t\\t\\t# no matter the exception, pop should quit if connected\\n\\t\\t\\tif cint(self.settings.use_imap):\\n\\t\\t\\t\\tself.imap.logout()\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.pop.quit()\\n\\n\\t\\treturn self.latest_messages\",\n \"def test_good_email():\\n good_email = \\\"me@dom.com\\\"\\n m = CannedRe.EMAIL.match(good_email)\\n # print getmembers(m)\\n assert m is not None, \\\"Canned RegEx email test failed for %s\\\" % good_email\\n assert m.string == good_email\",\n \"def get_mailing_list():\\n\\t\\tresult = {}\\n\\t\\tconnection = DbHelper.connect()\\n\\n\\t\\twith connection.cursor() as cursor:\\n\\t\\t\\tsql = \\\"SELECT email FROM mail_list \\\\\\n\\t\\t\\t\\t WHERE is_activated=1;\\\"\\n\\t\\t\\tcursor.execute(sql)\\n\\t\\t\\tresult = cursor.fetchall()\\n\\n\\t\\treturn [email_data['email'] for email_data in result]\",\n \"def email_lookup(self):\\n if not hasattr(self, \\\"_email_lookup\\\"):\\n self._email_lookup = {}\\n self.load_data()\\n for entry in self.data.get(\\\"contributor\\\", []):\\n if \\\"email\\\" in entry:\\n self._email_lookup[entry[\\\"email\\\"]] = entry\\n return self._email_lookup\",\n \"def person_didnt_downloaded_same_apps(other_email = 'rbaudibert@inf.ufrgs.br'):\\n try:\\n query = run_select_query('SELECT email \\\\\\n FROM \\\"User\\\" u \\\\\\n WHERE NOT EXISTS ( \\\\\\n SELECT * \\\\\\n FROM download \\\\\\n WHERE (u.email = download.user_email) \\\\\\n AND item_id IN ( \\\\\\n SELECT item_id \\\\\\n FROM download \\\\\\n WHERE (user_email = %s) \\\\\\n ) \\\\\\n );', (other_email,))\\n return [{'email': obj[0]} for obj in query]\\n except (Exception, psycopg2.Error) as error:\\n return {\\\"status\\\": \\\"error\\\", \\\"error\\\": error}\",\n \"def readMail(m, msgNum):#Read a particular email\\n resp, data = m.fetch(msgNum, \\\"(RFC822)\\\")\\n email_body = data[0][1]\\n mail = email.message_from_string(email_body)\\n #temp = m.store(emailid,'+FLAGS', '\\\\\\\\Seen')\\n m.expunge()\\n\\n\\n return mail\",\n \"def get_emails(params, start_response):\\n custodian = params.getfirst('custodian')\\n date = params.getfirst('date')\\n tfidf = params.getfirst('tfidf')\\n out = json.dumps(documents_out(custodian, date, tfidf))\\n status = '200 OK'\\n response_headers = [('Content-type', 'application/json'),\\n ('Access-Control-Allow-Origin', '*'),\\n ('Content-Length', str(len(out)))]\\n start_response(status, response_headers)\\n return [out]\",\n \"def get(self, email, application_category):\",\n \"def getMail():\\n\\n while 1:\\n #if 1==1:\\n \\n try:\\n Mailbox = poplib.POP3(c.Server['host'], c.Server['port']) \\n Mailbox.user(c.Server['username']) \\n Mailbox.pass_(c.Server['password']) \\n numMessages = len(Mailbox.list()[1])\\n \\n \\n log.info(\\\"Connected to %s and there are %i messages\\\"%(c.Server['host'], numMessages))\\n \\n for i in range(numMessages):\\n msg = Mailbox.top(i+1, 10000)\\n #msg = Mailbox.retr(i+1) # removes messages\\n qIncomingMail.put(msg)\\n log.debug(\\\"getMail: put message %i in queue\\\"%i)\\n Mailbox.quit()\\n \\n except:\\n log.error(\\\"Failed to connect to %s\\\"%c.Server['host'])\\n time.sleep(60)\",\n \"def get_accounts_for_emails(cls, emails):\\n return cls.get_by_key_name(['<%s>' % email for email in emails])\",\n \"def get_emails(self, token):\\n user_email_url = get_config('login.github.emails_info_url')\\n headers = {\\n \\\"Authorization\\\": \\\"token %s\\\" % token\\n }\\n email_info_resp = get_remote(user_email_url, headers)\\n email_list = json.loads(email_info_resp)\\n\\n return email_list\",\n \"def get_messages(email: str) -> list:\\n\\n params = {\\\"action\\\": \\\"getMessages\\\", \\\"login\\\": email, \\\"domain\\\": domain}\\n\\n response = requests.get(endpoint, data=params)\\n email_data = json.load(response)\\n\\n for email_message in email_data:\\n for field, value in email_message.items():\\n print(f\\\"{field}: {value}\\\")\\n print()\",\n \"def add(self, emails):\\r\\n request = http.Request('POST', self.get_url(), emails)\\r\\n\\r\\n return request, parsers.parse_json\",\n \"def update_mailing_list_extended(mailing_list):\\r\\n\\r\\n # Creating a copy of the original mailing list\\r\\n # This is necessary because we are going to exclude some keys (pop)\\r\\n mailing_list_copy = dict(mailing_list)\\r\\n\\r\\n # Looping over the mailing list and extracting key and value\\r\\n for key, value in mailing_list_copy.items():\\r\\n\\r\\n # Checks it the flag `opt-out` is present. We use lower() here to lowercase the flags and contemplate both\\r\\n # `opt-out` and `OPT-OUT` cases\\r\\n # Then, checks for the presence of the `unsubscribed` flag Finally,\\r\\n # checks if the email address contains `@gmail` provider\\r\\n if ('opt-out' in value[2].lower()) or \\\\\\r\\n ('unsubscribed' in value[2].lower()) or \\\\\\r\\n ('@gmail' in value[1]):\\r\\n # Remove the key if one of the above conditions is satisfied\\r\\n mailing_list.pop(key)\\r\\n\\r\\n # An array to collect the final output\\r\\n ids = []\\r\\n\\r\\n # Sort the updated mailing list alphabetically by `nickname`\\r\\n for items in sorted(mailing_list.items(), key=itemgetter(1), reverse=False):\\r\\n # Appending only the ids of the active users\\r\\n ids.append(items[0])\\r\\n\\r\\n # Returns the updated mailing list with the active users\\r\\n return ids\",\n \"def _ListReviewsForEmailAddress(self, email_address, output_writer):\\n issue_numbers = set()\\n\\n cursor = None\\n while True:\\n download_url = (\\n u'https://codereview.appspot.com/search?reviewer={0:s}'\\n u'&format=json&keys_only=False&with_messages=True').format(\\n email_address)\\n\\n # TODO: for now only search open issues.\\n # 1 => Unknown\\n # 2 => Yes\\n # 3 => No\\n if not self._include_closed:\\n download_url = u'{0:s}&closed=3'.format(download_url)\\n\\n if cursor:\\n download_url = u'{0:s}&cursor={1:s}'.format(download_url, cursor)\\n\\n reviews_data, response = self._DownloadPageContent(download_url)\\n if not reviews_data:\\n break\\n\\n # TODO: check if response is not None\\n _ = response\\n\\n reviews_json = json.loads(reviews_data)\\n\\n for review_values in self._ParserReviewsJSON(reviews_json):\\n if review_values[0] in issue_numbers:\\n # Skip issues numbers we've already processed.\\n return\\n\\n issue_numbers.add(review_values[0])\\n\\n # TODO: add in review status.\\n if review_values[5]:\\n status = u'closed'\\n elif review_values[4]:\\n status = u'in review'\\n else:\\n status = u'new'\\n\\n if not self._include_closed:\\n reviewers = u', '.join(review_values[4])\\n output_line = u'{0:s}\\\\t{1:s}\\\\t{2:d}\\\\t{3:s}\\\\t{4:s}\\\\t{5:s}\\\\n'.format(\\n review_values[0], review_values[1], review_values[2],\\n review_values[3], reviewers, status)\\n output_writer.Write(output_line.encode(u'utf-8'))\\n\\n else:\\n # Create a row per reviewer.\\n for reviewer in review_values[4]:\\n output_line = u'{0:s}\\\\t{1:s}\\\\t{2:d}\\\\t{3:s}\\\\t{4:s}\\\\t{5:s}\\\\n'.format(\\n review_values[0], review_values[1], review_values[2],\\n review_values[3], reviewer, status)\\n output_writer.Write(output_line.encode(u'utf-8'))\\n\\n cursor = reviews_json.get(u'cursor', None)\",\n \"def emails_parse(emails_dict):\\n result = emails_dict['ListVerifiedEmailAddressesResponse'][\\n 'ListVerifiedEmailAddressesResult']\\n emails = [email for email in result['VerifiedEmailAddresses']]\\n\\n return sorted(emails)\",\n \"def send_emails():\\n\\n cmd = \\\"sendmail -f git@dev.rtsoft.ru\\\"\\n for msg in EMAIL_MESSAGES:\\n for rec in RECIPIENTS:\\n call(\\\"echo '%s' | %s %s\\\" % (msg, cmd, rec), None, True)\",\n \"def get_emails_stat_by_campaigns(self, emails):\\n logger.info(\\\"Function call: get_emails_stat_by_campaigns\\\")\\n if not emails:\\n self.__handle_error(\\\"Empty emails\\\")\\n try:\\n emails = json.dumps(emails)\\n except:\\n logger.debug(\\\"Emails: {}\\\".format(emails))\\n return self.__handle_error(\\\"Emails list can't be converted by JSON library\\\")\\n return self.__handle_result(self.__send_request('emails/campaigns', 'POST', {'emails': emails}))\",\n \"def create_user_emails_sheets_all():\\n input_range = \\\"Sheet1\\\"\\n\\n sheetsService = build(\\n 'sheets', 'v4', credentials=credentials, cache_discovery=False)\\n\\n # Empty sheet\\n sheetsService.spreadsheets().values().clear(\\n spreadsheetId=spreadsheet_id, range=input_range).execute()\\n\\n # Get all basic users' email\\n users = list(User.objects.filter(is_active=True,\\n role=\\\"BU\\\").values('email', 'username', 'role', 'profile_id'))\\n\\n # Check their consent status and update accordingly\\n subscribers = []\\n for user in users:\\n if user['profile_id'] != None:\\n profile = SubscriberProfile.objects.get(id=user['profile_id'])\\n status = profile.consent_status\\n if status == \\\"IMPLIED\\\" and profile.expired_at < date.today():\\n profile.consent_status = \\\"EXPIRED\\\"\\n profile.save()\\n elif status == \\\"EXPRESSED\\\" or status == \\\"IMPLIED\\\":\\n user.pop('profile_id')\\n subscribers.append(user)\\n # Get newsletter only users' email\\n nlusers = list(NLUser.objects.all())\\n\\n # Check their consent status and update accordingly\\n for nluser in nlusers:\\n status = nluser.consent_status\\n if status == \\\"IMPLIED\\\" and nluser.expired_at < date.today():\\n nluser.consent_status = \\\"EXPIRED\\\"\\n nluser.save()\\n elif status == \\\"EXPRESSED\\\" or status == \\\"IMPLIED\\\":\\n subscribers.append({\\\"email\\\": nluser.email, \\\"username\\\": nluser.first_name,\\n \\\"role\\\": \\\"NL\\\"})\\n\\n # Get all basic users' email\\n restaurant_owners = list(\\n User.objects.filter(is_active=True, role=\\\"RO\\\").values('email', 'username', 'role'))\\n\\n # Append user info into values (only users that has email verified)\\n values = [['Email', 'Username', 'Role']]\\n for subscriber in subscribers:\\n values.append(list(subscriber.values()))\\n for restaurant_owner in restaurant_owners:\\n values.append(list(restaurant_owner.values()))\\n\\n body = {\\n 'values': values\\n }\\n\\n try:\\n sheetsService.spreadsheets().values().update(spreadsheetId=spreadsheet_id, range=input_range,\\n valueInputOption=\\\"USER_ENTERED\\\", body=body).execute()\\n except HttpError as error:\\n print('An error occurred: %s' % error)\\n raise error\\n # return None\\n\\n # Automatically format the sheets\\n requests = [\\n {\\n \\\"autoResizeDimensions\\\": {\\n \\\"dimensions\\\": {\\n \\\"sheetId\\\": 0,\\n \\\"dimension\\\": \\\"COLUMNS\\\",\\n \\\"startIndex\\\": 0,\\n \\\"endIndex\\\": 3\\n }\\n }\\n },\\n {\\n \\\"repeatCell\\\": {\\n \\\"range\\\": {\\n \\\"sheetId\\\": 0,\\n \\\"startRowIndex\\\": 0,\\n \\\"endRowIndex\\\": 1,\\n \\\"startColumnIndex\\\": 0,\\n \\\"endColumnIndex\\\": 3\\n },\\n \\\"cell\\\": {\\n \\\"userEnteredFormat\\\": {\\n \\\"textFormat\\\": {\\n \\\"bold\\\": True\\n }\\n }\\n },\\n \\\"fields\\\": \\\"userEnteredFormat(textFormat)\\\"\\n }\\n }\\n ]\\n\\n body = {\\n 'requests': requests\\n }\\n\\n try:\\n sheetsService.spreadsheets().batchUpdate(\\n spreadsheetId=spreadsheet_id, body=body).execute()\\n except HttpError as error:\\n print('An error occurred: %s' % error)\\n raise error\",\n \"def test_check_email(self):\\n url = reverse('check_email')\\n data = {\\\"emails\\\": [\\\"shashank.shekhar@vgmail.in\\\"]}\\n response_data = {\\\"results\\\": [{\\\"email\\\": \\\"shashank.shekhar@vgmail.in\\\", \\\"blocked\\\": True}], \\\"success\\\": True}\\n response = self.client.post(url, data, format='json')\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data, response_data)\",\n \"def enrich_user_by_email(email):\\n\\n result = {}\\n if settings.ENRICH_DATA:\\n clearbit.key = settings.CLEARBIT_API_KEY\\n try:\\n result = clearbit.Enrichment.find(email=email, stream=True)\\n except:\\n result = {}\\n\\n return result\",\n \"def test_check_email_endpoint(self, **kwargs):\\n email_id = kwargs.get('email_id', Workflows.generate_new_email(suffix=self.global_config[\\\"email_id_suffix\\\"]))\\n client_id = kwargs.get('client_id', self.global_config[\\\"client_id\\\"])\\n client_secret = kwargs.get('client_secret', self.global_config[\\\"client_secret\\\"])\\n relative_url = kwargs.get('url', self.test_args[\\\"relative_url\\\"]).format(email_id, client_id, client_secret)\\n\\n restapi = Rest(base_uri=self.global_config[\\\"base_url\\\"])\\n response = restapi.get(relative_url=relative_url, **kwargs)\\n if kwargs.get(\\\"return_response_obj\\\", False):\\n return response\\n\\n print(\\\"Verify Response body\\\")\\n assert json.loads(response.text)[\\\"data\\\"][\\\"available\\\"] == self.test_args[\\\"expected_result\\\"], \\\"Test Failed\\\"\\n return None\",\n \"def IP_list(pwd):\\r\\n # Connect to the gmail server.\\r\\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\\r\\n mail.login('arc.pi.reg@gmail.com', pwd)\\r\\n\\r\\n # get mail IDs.\\r\\n mail.select('Inbox')\\r\\n typ, data = mail.search(None, '(From \\\"arc.pi.reg\\\")')\\r\\n mail_ids = data[0].decode()\\r\\n id_list = mail_ids.split()\\r\\n\\r\\n pi_ip = []\\r\\n\\r\\n # More description here.\\r\\n for id in id_list[::-1]:\\r\\n typ, msg_data = mail.fetch(id, '(BODY.PEEK[TEXT])')\\r\\n msg = msg_data[0][1].decode().strip()\\r\\n\\r\\n name, addr = msg.split(\\\" \\\")\\r\\n pi_ip.append((name, addr))\\r\\n\\r\\n return pi_ip\",\n \"def checkUserEmail(email, number):\\n\\n if number == 1:\\n flag = 0\\n atflag = False\\n for i in email:\\n if i == \\\"@\\\":\\n atflag=True\\n flag += 1\\n if i == \\\".\\\" and atflag:\\n flag += 1\\n if flag != 2:\\n return False\\n return True\\n if number == 2:\\n c.execute(\\\"select email from users where email = ?\\\", (email,))\\n if c.fetchall():\\n return True\\n return False\",\n \"def test_skip_blank_emails(self):\\n appt_date = datetime.date.today() + datetime.timedelta(days=7) # Default for email\\n confirmed = self.create_confirmed_notification(self.test_patient, appt_date)\\n\\n blank_contact = self.create_contact(data={'email': ''})\\n self.group.contacts.add(blank_contact)\\n\\n # run email job\\n from aremind.apps.reminders.app import daily_email_callback\\n daily_email_callback(self.router)\\n\\n self.assertEqual(len(mail.outbox), 1)\\n message = mail.outbox[0]\\n self.assertEqual(len(message.to), 1)\",\n \"def check_mail(self, update=False):\\r\\n return self.check_mail_dir(update=update)\",\n \"def send_email(recent_seach_tweets):\\n # Create e-mail message\\n msg = C.intro + C.message_init.format(number_flash_cards=len(recent_seach_tweets))\\n # Add a special text for the first 3 new tweets \\n for tw in recent_seach_tweets[:3]:\\n date = tw['date'].strftime('Le %d/%m/%Y à %H:%M')\\n link_tweet = tw['tweet_link']\\n link_picture = tw['images'][0]\\n tweet_text = tw[\\\"text\\\"][:tw[\\\"text\\\"].index('#')-1]\\n msg += C.flashcard.format(date=date, \\n link_picture=link_picture, \\n tweet_text=tweet_text,\\n tweet_link=link_tweet)\\n\\n # mapping for the subject\\n numbers = { 0 : 'zero', 1 : 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5 : 'five',\\n 6 : 'six', 7 : 'seven', 8 : 'eight', 9 : 'nine', 10 : 'ten'}\\n\\n message = MIMEText(msg, 'html')\\n message['From'] = formataddr((str(Header('Twitter Parser', 'utf-8')), C.my_email_address))\\n message['To'] = C.dest\\n message['Subject'] = '%s new Machine Learning Flash Cards' % numbers[len(recent_seach_tweets)].title()\\n msg_full = message.as_string()\\n\\n server = smtplib.SMTP('smtp.gmail.com:587')\\n server.starttls()\\n server.login(C.my_email_address, C.password)\\n server.sendmail(C.my_email_address, C.dest, msg_full)\\n server.quit()\\n print('%s - E-mail sent!' % datetime.datetime.now().strftime('%d/%m/%Y - %H:%M'))\",\n \"def check_gmail(username, password):\\n i = imaplib.IMAP4_SSL('imap.gmail.com')\\n try:\\n i.login(username, password)\\n x, y = i.status('INBOX', '(MESSAGES UNSEEN)')\\n messages = int(re.search('MESSAGES\\\\s+(\\\\d+)', y[0]).group(1))\\n unseen = int(re.search('UNSEEN\\\\s+(\\\\d+)', y[0]).group(1))\\n return messages, unseen\\n except:\\n return False, 0\",\n \"def test_email_search(self):\\n # A name in the database\\n search_string = \\\"umut@gmail.com\\\"\\n # Search For Umut\\n resp = SearchTest.client.get('/api/search/',{\\\"token\\\":SearchTest.valid_token,\\\"search_string\\\":search_string})\\n search_result = json.loads(resp.content)\\n # Check the e_mail field of the result\\n self.assertEqual(search_string,search_result[0]['e_mail'],\\\"It doesn't return the user with the email {}\\\".format(search_string))\",\n \"def extract_emails_from_category(initial_url, first_page=int(1)):\\r\\n\\tresult_emails = set() #we will return this\\r\\n\\t#last page regex\\r\\n\\tlp_regex = re.compile('[0-9]+/;')\\r\\n\\t#Open URL\\r\\n\\tsoup = bs4.BeautifulSoup(urlopen(initial_url), \\\"html5lib\\\")\\r\\n\\t#extract the link to the last page. It is inside div.paging-bottom > ul > li with text \\\">>\\\"\\r\\n\\tnavigation = soup.find_all(\\\"div\\\",id=\\\"paging-bottom\\\")\\r\\n\\tif not navigation:\\r\\n\\t\\tprint(\\\"This page is weird. It has no navigation. Aborting\\\\n\\\")\\r\\n\\t\\treturn result_emails\\r\\n\\r\\n\\ttxt_elem = navigation[0].ul.find_all(text=\\\">>\\\")[0]\\r\\n\\t#link to last page\\r\\n\\tlink = txt_elem.parent\\r\\n\\t#Get its url.. smthg like /ourivesarias-joalharias/134/;jsessionid=67E1932531B84B3E77AAF47A29B263CE\\r\\n\\turl = link['href']\\r\\n\\t#Pick the number of the last page\\r\\n\\tmatch = lp_regex.search(url)\\r\\n\\tif match:\\r\\n\\t\\tlast_page = match.group()[0:-2]\\r\\n\\t\\tlast_page_i = int(last_page)\\r\\n\\telse:\\r\\n\\t\\tprint(\\\"This category has no navigation to the last page\\\\n\\\")\\r\\n\\t\\tlast_page_i = first_page\\r\\n\\t\\t\\r\\n\\t#Sanity Check\\r\\n\\tif last_page_i < first_page:\\r\\n\\t\\tlast_page_i = first_page\\r\\n\\t\\t\\r\\n\\tprint(\\\"Working on category %s\\\" % initial_url)\\r\\n\\t#Now that we have the last page. Time to iterate on each one and get the emails\\r\\n\\tfor page in xrange( first_page, last_page_i ):\\r\\n\\t\\tpage_url = initial_url + str(page) + '/' #This is fragile\\r\\n\\t\\tprint(\\\"Scanning page %d of %d (%s).\\\" % (page, last_page_i, page_url))\\r\\n\\t\\ttry:\\r\\n\\t\\t\\temails = extract_emails_from_page(bs4.BeautifulSoup( unicode(urlopen(page_url).read(),'utf-8','ignore'), \\\"html5lib\\\"))\\r\\n\\t\\t\\twrite_emails_to_set(emails, result_emails)\\r\\n\\t\\t\\ttime.sleep(5)\\r\\n\\t\\texcept IOError:\\r\\n\\t\\t\\tprint(\\\"Coult not fetch url %s. Skipped\\\\n\\\" % page_url)\\r\\n\\treturn result_emails\",\n \"def get_all_pastes_for_account(self, email):\\n return self._do_request(urljoin(\\\"pasteaccount\\\", email))\",\n \"def __get_emails(self):\\n # This returns a list of Gmail message objects. Documentation can be found at\\n # https://developers.google.com/gmail/api/v1/reference/users/messages/list\\n return self.__service.users().messages().list(userId='me').execute()['messages']\",\n \"def get_email(self):\\n # Scraping the Email Address from Contact Info (email)\\n\\n # > click on 'Contact info' link on the page\\n # self.browser.execute_script(\\n # \\\"(function(){try{for(i in document.getElementsByTagName('a')){let el = document.getElementsByTagName('a')[i]; \\\"\\n # \\\"if(el.innerHTML.includes('Contact info')){el.click();}}}catch(e){}})()\\\")\\n # time.sleep(loading_pause_time)\\n #\\n # # > gets email from the 'Contact info' popup\\n # try:\\n # email = self.browser.execute_script(\\n # \\\"return (function(){try{for (i in document.getElementsByClassName('pv-contact-info__contact-type')){ let \\\"\\n # \\\"el = \\\"\\n # \\\"document.getElementsByClassName('pv-contact-info__contact-type')[i]; if(el.className.includes(\\\"\\n # \\\"'ci-email')){ \\\"\\n # \\\"return el.children[2].children[0].innerText; } }} catch(e){return '';}})()\\\")\\n #\\n # self.browser.execute_script(\\\"document.getElementsByClassName('artdeco-modal__dismiss')[0].click()\\\")\\n # except:\\n # email = 'N/A'\",\n \"def fetchmail(self):\\n mails = []\\n\\n if self.security == 'SSL/TLS':\\n imap = IMAP4_SSL(self.host, self.port)\\n else:\\n imap = IMAP4(self.host, self.port)\\n if self.security == 'STARTTLS':\\n imap.starttls()\\n imap.login(self.username, self.passwd)\\n imap.select(readonly=True)\\n\\n status, uids = imap.uid('SEARCH', 'UNSEEN')\\n\\n for uid in uids[0].split():\\n status, data = imap.uid('FETCH', uid, '(BODY[HEADER.FIELDS (DATE SUBJECT FROM)])')\\n message = self._message_from_data(data)\\n mail = Mail(uid, message['FROM'], message['SUBJECT'], message['DATE'])\\n mails.append(mail)\\n\\n imap.close()\\n imap.logout()\\n\\n return mails\",\n \"def lookup_email(args):\\n db = cache.get_default()\\n if args.forced:\\n db.lookup_email(args.address)\\n try:\\n info = db.get_email(args.address, nolookup=args.cached)\\n print('{!r:} is {:s}valid: {:s}.'.format(info.address, '' if info.is_valid else 'in',\\n info.reason))\\n except exceptions.CacheMissException:\\n exit('{!r:} is not in the cache.'.format(args.address))\",\n \"def _filter_emails(emails):\\n rv = []\\n for email in emails:\\n if _email_is_valid(email):\\n rv.append(email)\\n else:\\n print 'WARNING: Not including %s (invalid email address)' % email\\n return rv\",\n \"def new_email(self, context, payload):\\n\\n access_token = util.get_access_token(context['headers'])\\n url = util.get_url(context) + f\\\"messages/{payload['id']}\\\"\\n response = util.rest(\\\"GET\\\", url, access_token)\\n\\n if response.status_code > 400:\\n raise Exception(\\\"Error \\\", response.text)\\n\\n email_obj = json.loads(response.text)\\n\\n return GmailApi.get_email_data(email_obj)\",\n \"def copyToLdap(user_email):\\n user = User.objects.get(email=user_email)\\n social = user.social_auth.get(provider='google-oauth2')\\n print (\\\"Get social\\\")\\n print (social)\\n domain = user_email.split('@')[1]\\n print(domain)\\n response = requests.get(\\n 'https://www.googleapis.com/admin/directory/v1/users?domain={}'.format(domain),\\n params={'access_token': social.extra_data['access_token']}\\n )\\n print (response.json())\\n gappsUsers = response.json().get('users')\\n # update records\\n confirmedLdapUsers = []\\n for gUser in gappsUsers:\\n print (gUser.get('primaryEmail'))\\n try:\\n usr = LdapUser.objects.get(email=gUser.get('primaryEmail'))\\n #check if user needs to be deleted\\n if gUser['suspended']:\\n usr.delete()\\n continue\\n except LdapUser.DoesNotExist:\\n if gUser['suspended']:\\n continue\\n usr = LdapUser(email=gUser.get('primaryEmail'), password = ''.join(secrets.choice(ALPHABET) for i in range(10)))\\n \\n usr.group = 1\\n usr.uid = gUser['id'] \\n usr.first_name = gUser['name']['givenName']\\n usr.last_name = gUser['name']['familyName']\\n usr.full_name = gUser['name']['fullName']\\n usr.username = gUser.get('primaryEmail')\\n usr.home_directory = \\\"/\\\"\\n usr.save()\\n\\n confirmedLdapUsers.append(usr.email)\\n\\n #delete users from ldap that are not gApps users\\n LdapUser.objects.all().exclude(email__in=confirmedLdapUsers).delete()\\n\\n return domain\",\n \"def missing_emails(master_dataframe):\\n\\tmaster, nine, ten, eleven, twelve = master_dataframe(threshold)\\n\\tmissing_email = master_dataframe['email'].isnull()\\n\\n\\tl = set()\\n\\tfor id_num, value in missing_email.iteritems():\\n\\t\\tif value == True:\\n\\t\\t\\tl.add(id_num)\\n\\td = {}\\n\\tfor i in master.iterrows():\\n\\t\\tid_num = i[0]\\n\\t\\tif id_num in l:\\n\\t\\t\\tlast_name = i[1][1]\\n\\t\\t\\tfirst_name = i[1][2]\\n\\t\\t\\tname = (last_name, first_name)\\n\\t\\t\\td[id_num] = name\\n\\n\\tw = csv.writer(open(\\\"missing_email.csv\\\", \\\"w\\\"))\\n\\n\\tfor key, val in d.items():\\n\\t\\tw.writerow([key,val])\",\n \"def test_get_many(self, requests_mock, accepts_marketing, emails):\\n matcher = requests_mock.post(\\n f'{settings.CONSENT_SERVICE_BASE_URL}'\\n f'{consent.CONSENT_SERVICE_PERSON_PATH_LOOKUP}',\\n json={\\n 'results': [\\n {\\n 'email': email,\\n 'consents': [\\n CONSENT_SERVICE_EMAIL_CONSENT_TYPE,\\n ] if accepts_marketing else [],\\n } for email in emails\\n ],\\n },\\n status_code=status.HTTP_200_OK,\\n )\\n resp = consent.get_many(emails)\\n assert resp == {email: accepts_marketing for email in emails}\\n\\n assert matcher.called_once\\n assert matcher.last_request.query == f'limit={len(emails)}'\\n assert matcher.last_request.json() == {'emails': emails}\",\n \"def check_duplicate_email(self, email):\\r\\n request = self.req_factory.post('unused_url', data={\\r\\n 'new_email': email,\\r\\n 'password': 'test',\\r\\n })\\r\\n request.user = self.user\\r\\n self.assertFailedRequest(self.run_request(request), 'An account with this e-mail already exists.')\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n user_id = 'me'\\n\\n ## get_labels ##\\n #print_all_labels(service,user_id)\\n #fetch_and_store(service,user_id)\\n #apply_rules()\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('gmail', 'v1', http=http)\\n\\n results = service.users().labels().list(userId='me').execute()\\n labels = results.get('labels', [])\\n\\n FPS = 30\\n WINDOWWIDTH = 480\\n WINDOWHEIGHT = 320\\n\\n WHITE = (255, 255, 255)\\n RED = (255, 0, 0)\\n BLUE = (0, 0, 255)\\n GREEN = (0, 255, 0)\\n BLACK = (0, 0, 0)\\n LIGHTGREEN = (53, 230, 97)\\n LIGHTBLUE = (53, 156, 230)\\n LIGHTORANGE = (242, 109, 19)\\n\\n windowBgColor = WHITE\\n\\n pygame.init()\\n FPSCLOCK = pygame.time.Clock()\\n DISPLAYSURFACE = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))\\n pygame.display.set_caption('PLUTO')\\n\\n myfont = pygame.font.Font(None, 30)\\n label = myfont.render(\\\"<-- Enter address\\\", 1, BLACK)\\n\\n buttonEnterEmail = pygbutton.PygButton((10, 10, 100, 80), 'Enter Email', bgcolor=LIGHTORANGE)\\n buttonScan = pygbutton.PygButton((10, 100, 225, 210), 'Scan and Send', bgcolor=LIGHTGREEN, font=myfont)\\n buttonReceive = pygbutton.PygButton((245, 100, 225, 210), 'Receive and Print', bgcolor=LIGHTBLUE, font=myfont)\\n buttonPrintICR = pygbutton.PygButton((370, 10, 100, 80), 'Letterhead', bgcolor=RED)\\n winBgButtons = (buttonEnterEmail, buttonScan, buttonReceive, buttonPrintICR)\\n\\n allButtons = winBgButtons\\n\\n userinput = \\\"\\\"\\n\\n while True:\\n for event in pygame.event.get(): # event handling loop\\n \\n if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):\\n pygame.quit()\\n sys.exit()\\n\\n if 'click' in buttonReceive.handleEvent(event): #User called for printing of file\\n \\n idenListCurr = ListMessagesMatchingQuery(service, 'me', 'in:inbox')\\n idenListLast = None\\n \\n #if idenListLast != idenListCurr: #to be used in future with inbox functionality\\n\\n #msgList = [] #should be a way to do this where only add the new messages\\n \\n #for each in idenListCurr:\\n #iden = each[u'id']\\n #mimeMsg = GetMimeMessage(service, 'me', iden)\\n \\n #msgList.append(mimeMsg)\\n\\n #idenListLast = idenListCurr\\n \\n\\n #displayInterface(msgList)\\n htmlMsg = GetRawMessageHtml(service, 'me', idenListCurr[0][u'id'])\\n writeFile(htmlMsg, \\\"temp\\\", \\\"html\\\")\\n \\n try:\\n pdfkit.from_file(\\\"/home/pi/git/PlutoTest/temp.html\\\", \\\"temp.pdf\\\") #change to your directory\\n except IOError:\\n pass\\n \\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"Your message will print\\\")\\n printCups.executePrint(\\\"/home/pi/git/PlutoTest/temp.pdf\\\") #change to your directory\\n os.remove(\\\"/home/pi/git/PlutoTest/temp.pdf\\\") #change to your directory\\n os.remove(\\\"/home/pi/git/PlutoTest/temp.html\\\") #change to your directory\\n time.sleep(5)\\n \\n if 'click' in buttonScan.handleEvent(event):#user called for scanning and sending of file\\n scan.executeScan(\\\"temp\\\")\\n \\n message = CreateMessageWithAttachment(\\\"example.pluto.email@gmail.com\\\", userinput, \\\"Hello from Pluto!\\\", \\\"Enjoy!\\\",\\n \\\"/home/pi/git/PlutoTest/\\\", \\\"temp.png\\\") #change to your email, directory\\n SendMessage(service, 'me', message)\\n \\n \\n os.remove(\\\"/home/pi/git/PlutoTest/temp.png\\\") #change to your directory\\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"Your message has been sent\\\")\\n print(\\\"sent\\\")\\n time.sleep(5)\\n \\n if 'click' in buttonEnterEmail.handleEvent(event): #user called to enter e-mail address\\n vkeybd = VirtualKeyboard(DISPLAYSURFACE)\\n tempInput = vkeybd.run(\\\"...\\\")\\n if tempInput != \\\"...\\\":\\n userinput = tempInput\\n label = myfont.render(\\\"To: \\\" + userinput, 1, BLACK)\\n \\n if 'click' in buttonPrintICR.handleEvent(event): #user called to print letterhead\\n popup = Popup(DISPLAYSURFACE)\\n tempInput = popup.run(\\\"The letterhead will print\\\")\\n printCups.executePrint(\\\"/home/pi/git/PlutoTest/DemoPaper.png\\\") #change to your directory\\n time.sleep(5)\\n\\n\\n DISPLAYSURFACE.fill(windowBgColor)\\n\\n for b in allButtons:\\n b.draw(DISPLAYSURFACE)\\n\\n # draw the text onto the surface\\n DISPLAYSURFACE.blit(label, (120, 35, 350, 80))\\n\\n pygame.display.update()\\n FPSCLOCK.tick(FPS)\",\n \"def opt_in(msg_hash):\\r\\n email, removed = Email.handler.opt_in(msg_hash)\\r\\n if email and removed:\\r\\n Email.handler.add_to_queue(None, None, [email], \\\"reddit.com\\\",\\r\\n datetime.datetime.now(g.tz),\\r\\n '127.0.0.1', Email.Kind.OPTIN)\\r\\n return email, removed\",\n \"def api_check_email(request):\\n email = request.matchdict['email']\\n check_email = RepositorioUsario.check_email(request, email)\\n\\n return check_email\",\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def test_skip_blank_emails(self):\\n appt_date = datetime.date.today() + datetime.timedelta(days=7) # Default for email\\n reminders.Patient.objects.filter(\\n pk__in=[self.test_patient.pk, self.other_patient.pk]\\n ).update(next_visit=appt_date)\\n confirmed = self.create_confirmed_notification(self.test_patient, appt_date)\\n blank_contact = self.create_contact(data={'email': ''})\\n null_contact = self.create_contact(data={'email': None})\\n self.group.contacts.add(blank_contact)\\n self.group.contacts.add(null_contact)\\n\\n self.startRouter()\\n self.router.logger.setLevel(logging.DEBUG)\\n # run email job\\n from afrims.apps.reminders.app import daily_email_callback\\n daily_email_callback(self.router)\\n\\n self.assertEqual(len(mail.outbox), 1)\\n message = mail.outbox[0]\\n self.assertEqual(len(message.to), 1)\\n self.stopRouter()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6836338","0.68140227","0.6734633","0.6701311","0.6606506","0.6500365","0.649841","0.6341374","0.6327239","0.6249059","0.62106127","0.61267984","0.61160463","0.60011953","0.59610665","0.59563863","0.5922605","0.5915454","0.5888645","0.586136","0.58241683","0.5811862","0.5769649","0.57659566","0.57523346","0.57279396","0.5657786","0.5632555","0.560789","0.5590702","0.55496335","0.5548287","0.55419666","0.5535154","0.552346","0.5523026","0.5512454","0.5512061","0.5506593","0.54984474","0.549357","0.54853946","0.54788727","0.5475442","0.54224163","0.5410537","0.53789854","0.5360658","0.5354882","0.5352491","0.5325596","0.53127885","0.53019685","0.526134","0.5252338","0.5248185","0.5240326","0.5235915","0.52288514","0.52284133","0.5209604","0.5204302","0.52042496","0.5199981","0.5196871","0.51903373","0.51812744","0.5171943","0.5163327","0.51577413","0.51566726","0.5153846","0.5151286","0.51484877","0.5146643","0.514104","0.5129488","0.5128929","0.5116383","0.5115663","0.51009816","0.5100778","0.50846","0.50819093","0.5060449","0.5055099","0.50480306","0.5047872","0.5038426","0.50378615","0.5032293","0.5026188","0.50177586","0.50131035","0.50125784","0.5011322","0.50110006","0.5006488","0.50060225","0.5002433"],"string":"[\n \"0.6836338\",\n \"0.68140227\",\n \"0.6734633\",\n \"0.6701311\",\n \"0.6606506\",\n \"0.6500365\",\n \"0.649841\",\n \"0.6341374\",\n \"0.6327239\",\n \"0.6249059\",\n \"0.62106127\",\n \"0.61267984\",\n \"0.61160463\",\n \"0.60011953\",\n \"0.59610665\",\n \"0.59563863\",\n \"0.5922605\",\n \"0.5915454\",\n \"0.5888645\",\n \"0.586136\",\n \"0.58241683\",\n \"0.5811862\",\n \"0.5769649\",\n \"0.57659566\",\n \"0.57523346\",\n \"0.57279396\",\n \"0.5657786\",\n \"0.5632555\",\n \"0.560789\",\n \"0.5590702\",\n \"0.55496335\",\n \"0.5548287\",\n \"0.55419666\",\n \"0.5535154\",\n \"0.552346\",\n \"0.5523026\",\n \"0.5512454\",\n \"0.5512061\",\n \"0.5506593\",\n \"0.54984474\",\n \"0.549357\",\n \"0.54853946\",\n \"0.54788727\",\n \"0.5475442\",\n \"0.54224163\",\n \"0.5410537\",\n \"0.53789854\",\n \"0.5360658\",\n \"0.5354882\",\n \"0.5352491\",\n \"0.5325596\",\n \"0.53127885\",\n \"0.53019685\",\n \"0.526134\",\n \"0.5252338\",\n \"0.5248185\",\n \"0.5240326\",\n \"0.5235915\",\n \"0.52288514\",\n \"0.52284133\",\n \"0.5209604\",\n \"0.5204302\",\n \"0.52042496\",\n \"0.5199981\",\n \"0.5196871\",\n \"0.51903373\",\n \"0.51812744\",\n \"0.5171943\",\n \"0.5163327\",\n \"0.51577413\",\n \"0.51566726\",\n \"0.5153846\",\n \"0.5151286\",\n \"0.51484877\",\n \"0.5146643\",\n \"0.514104\",\n \"0.5129488\",\n \"0.5128929\",\n \"0.5116383\",\n \"0.5115663\",\n \"0.51009816\",\n \"0.5100778\",\n \"0.50846\",\n \"0.50819093\",\n \"0.5060449\",\n \"0.5055099\",\n \"0.50480306\",\n \"0.5047872\",\n \"0.5038426\",\n \"0.50378615\",\n \"0.5032293\",\n \"0.5026188\",\n \"0.50177586\",\n \"0.50131035\",\n \"0.50125784\",\n \"0.5011322\",\n \"0.50110006\",\n \"0.5006488\",\n \"0.50060225\",\n \"0.5002433\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5653958"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":9477,"cells":{"query":{"kind":"string","value":"Create a message for an email."},"document":{"kind":"string","value":"def create_message(sender, to, subject, message_text):\n message = MIMEText(message_text)\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n raw = base64.urlsafe_b64encode(message.as_bytes())\n return {'raw':raw.decode()}"},"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 createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )","def createMessage( self, *args, **kw ):\n if not kw.has_key('charset'):\n kw['charset'] = self.getOutputCharset()\n kw['to_mail'] = 1\n return MailServerBase.createMessage( self, *args, **kw )","def _createEmail(self, address_to, message, emailSubject):\r\n\t\tfrom_email = Email(self.sender)\r\n\t\tto_email = To(address_to)\r\n\t\tsubject = emailSubject\r\n\t\tcontent = Content(\"text/plain\", message)\r\n\t\t#creates Mail object from sendgrid api\r\n\t\tmail = Mail(from_email, to_email, subject, content)\r\n\t\treturn mail","def create_message(sender, to, subject, cc, message_text):\n\n email = \"\"\n \n for c in message_text:\n email += c\n \n message = MIMEText(email)\n message['to'] = to\n message['cc'] = cc\n message['from'] = sender\n message['subject'] = subject\n return {'raw': base64.urlsafe_b64encode(message.as_string())}","def __create_message(sender, recipients, subject, message_text):\n message = {\n \"to\": recipients,\n \"from_email\": sender,\n \"subject\": subject,\n \"html\": message_text,\n }\n\n return message","def _create_email(\n to_field=\"to_user@test1.com\",\n from_field=\"from_user@test2.com\",\n subject=\"This is a test email\",\n body=\"Almost empty text message\",\n attachment=None,\n maintype=None,\n subtype=None,\n):\n msg = EmailMessage()\n\n msg['To'] = to_field\n msg['From'] = from_field\n msg['Subject'] = subject\n msg.set_content(body)\n\n if attachment:\n with open(attachment, 'rb') as fp:\n attachment = fp.read()\n\n msg.add_attachment(attachment, maintype=maintype, subtype=subtype)\n\n email_message = email.message_from_bytes(\n msg.as_bytes(),\n policy=email.policy.default\n )\n\n return email_message","def create_message(sender, to, subject, message_text):\r\n message = MIMEText(message_text)\r\n message['to'] = to\r\n message['from'] = sender\r\n message['subject'] = subject\r\n raw = base64.urlsafe_b64encode(message.as_bytes())\r\n raw = raw.decode()\r\n body = {'raw': raw}\r\n return body","def createMessage( self, *args, **kw ):\n if not kw.has_key('charset'):\n kw['charset'] = self.getInputCharset()\n return MailServerBase.createMessage( self, *args, **kw )","def make_message(self, mto, mbody=None, msubject=None, mtype=None,\n mhtml=None, mfrom=None, mnick=None):\n message = self.Message(sto=mto, stype=mtype, sfrom=mfrom)\n message['body'] = mbody\n message['subject'] = msubject\n if mnick is not None:\n message['nick'] = mnick\n if mhtml is not None:\n message['html']['body'] = mhtml\n return message","def CreateMessage(sender, to, subject, message_text):\n message = MIMEText(message_text, 'html')\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}","def create_message(sender, to, subject, message_text_html, message_text_plain):\r\n message = MIMEMultipart('alternative')\r\n message['to'] = to\r\n message['from'] = sender\r\n message['subject'] = subject\r\n message_html = MIMEText(message_text_html, 'html') # HTML version\r\n message_plain = MIMEText(message_text_plain) # plain text version\r\n message.attach(message_plain)\r\n message.attach(message_html)\r\n return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}","def createMessage(self, sender: str, to: str, subject: str, message_text: str):\n message = MIMEText(message_text)\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n raw_message = {'raw': base64.urlsafe_b64encode(message.as_bytes())}\n raw_message['raw']=raw_message['raw'].decode('utf-8')\n return raw_message","def get_message(self, **kwargs):\n message = Mail()\n if \"from_email\" in kwargs:\n sender = Email()\n message_content = kwargs.get(\"message_content\", \"\")\n sender.name = message_content.get(\"sender\", emailconf.DEFAULT_SENDER)\n sender.email = kwargs.get(\"from_email\", emailconf.DEFAULT_SENDER_EMAIL)\n message.from_email = sender\n if \"subject\" in kwargs:\n message.subject = kwargs.get(\"subject\", \"\")\n if \"text\" in kwargs:\n content = Content(\"text/plain\", kwargs.get(\"text\", \"\"))\n message.add_content(content)\n if \"html\" in kwargs:\n content = Content(\"text/html\", kwargs.get(\"html\", \"\"))\n message.add_content(content)\n if \"category\" in kwargs:\n category = Category(kwargs.get(\"category\", \"\"))\n message.add_category(category)\n\n personalization = self.create_personalization(**kwargs)\n if personalization:\n message.add_personalization(personalization)\n\n return message.get()","def create_message(text: str, room: str, creating_user: str, receiving_user: str, channel: models.PrivateChannel):\n message = models.Message(\n text=text,\n creating_user=creating_user,\n receiving_user=receiving_user,\n channel_id=channel.id,\n room=room\n )\n db.session.add(message)\n db.session.commit()","def create_message(self, subject, message, destination, origin = None):\n msg = MIMEText(message)\n if origin is not None:\n msg['From'] = origin\n else:\n msg['From'] = self.origin\n msg['Subject'] = subject\n msg['To'] = destination\n self.messages.append(msg)","def create_email(sender, to, subject, message_text):\n # This is intended to strip non-ascii chars in message_text\n message_text = ''.join(filter(lambda x: x in printable, message_text))\n \n message = MIMEText(message_text)\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n return message.as_bytes()","def _make_message(request, issue, message, comments=None, send_mail=False,\n draft=None, in_reply_to=None):\n attach_patch = request.POST.get(\"attach_patch\") == \"yes\"\n template, context = _get_mail_template(request, issue, full_diff=attach_patch)\n # Decide who should receive mail\n my_email = db.Email(request.user.email())\n to = ([db.Email(issue.owner.email())] +\n issue.reviewers +\n [db.Email(email) for email in issue.collaborator_emails()])\n cc = issue.cc[:]\n if django_settings.RIETVELD_INCOMING_MAIL_ADDRESS:\n cc.append(db.Email(django_settings.RIETVELD_INCOMING_MAIL_ADDRESS))\n reply_to = to + cc\n if my_email in to and len(to) > 1: # send_mail() wants a non-empty to list\n to.remove(my_email)\n if my_email in cc:\n cc.remove(my_email)\n issue_id = issue.key.id()\n subject = issue.mail_subject()\n patch = None\n if attach_patch:\n subject = 'PATCH: ' + subject\n if 'patch' in context:\n patch = context['patch']\n del context['patch']\n if issue.num_messages:\n subject = 'Re: ' + subject\n if comments:\n details = _get_draft_details(request, comments)\n else:\n details = ''\n message = message.replace('\\r\\n', '\\n')\n text = ((message.strip() + '\\n\\n' + details.strip())).strip()\n if draft is None:\n msg = models.Message(issue_key=issue.key,\n subject=subject,\n sender=my_email,\n recipients=reply_to,\n text=text,\n parent=issue.key,\n issue_was_closed=issue.closed)\n else:\n msg = draft\n msg.subject = subject\n msg.recipients = reply_to\n msg.text = text\n msg.draft = False\n msg.date = datetime.datetime.now()\n msg.issue_was_closed = issue.closed\n issue.calculate_updates_for(msg)\n\n if in_reply_to:\n try:\n replied_msg_id = int(in_reply_to)\n replied_msg = models.Message.get_by_id(replied_msg_id, parent=issue.key)\n msg.in_reply_to_key = replied_msg.key\n replied_issue_id = replied_msg.issue_key.id()\n if replied_issue_id != issue_id:\n logging.warn('In-reply-to Message is for a different issue: '\n '%s instead of %s', replied_issue_id, issue_id)\n msg.in_reply_to_key = None\n except (db.KindError, db.BadKeyError, ValueError):\n logging.warn('Invalid in-reply-to Message or key given: %s', in_reply_to)\n\n if send_mail:\n # Limit the list of files in the email to approximately 200\n if 'files' in context and len(context['files']) > 210:\n num_trimmed = len(context['files']) - 200\n del context['files'][200:]\n context['files'].append('[[ %d additional files ]]' % num_trimmed)\n url = request.build_absolute_uri(reverse(show, args=[issue.key.id()]))\n reviewer_nicknames = ', '.join(library.get_nickname(rev_temp, True,\n request)\n for rev_temp in issue.reviewers)\n cc_nicknames = ', '.join(library.get_nickname(cc_temp, True, request)\n for cc_temp in cc)\n my_nickname = library.get_nickname(request.user, True, request)\n reply_to = ', '.join(reply_to)\n description = (issue.description or '').replace('\\r\\n', '\\n')\n home = request.build_absolute_uri(reverse(index))\n modified_added_count, modified_removed_count = _get_modified_counts(issue)\n context.update({'reviewer_nicknames': reviewer_nicknames,\n 'cc_nicknames': cc_nicknames,\n 'my_nickname': my_nickname, 'url': url,\n 'message': message, 'details': details,\n 'description': description, 'home': home,\n 'added_lines' : modified_added_count,\n 'removed_lines': modified_removed_count,\n })\n for key, value in context.iteritems():\n if isinstance(value, str):\n try:\n encoding.force_unicode(value)\n except UnicodeDecodeError:\n logging.error('Key %s is not valid unicode. value: %r' % (key, value))\n # The content failed to be decoded as utf-8. Enforce it as ASCII.\n context[key] = value.decode('ascii', 'replace')\n body = django.template.loader.render_to_string(\n template, context, context_instance=RequestContext(request))\n logging.warn('Mail: to=%s; cc=%s', ', '.join(to), ', '.join(cc))\n send_args = {'sender': my_email,\n 'to': [_encode_safely(address) for address in to],\n 'subject': _encode_safely(subject),\n 'body': _encode_safely(body),\n 'reply_to': _encode_safely(reply_to)}\n if cc:\n send_args['cc'] = [_encode_safely(address) for address in cc]\n if patch:\n send_args['attachments'] = [('issue_%s_patch.diff' % issue.key.id(),\n patch)]\n\n attempts = 0\n while True:\n try:\n mail.send_mail(**send_args)\n break\n except mail.InvalidSenderError:\n if django_settings.RIETVELD_INCOMING_MAIL_ADDRESS:\n previous_sender = send_args['sender']\n if previous_sender not in send_args['to']:\n send_args['to'].append(previous_sender)\n send_args['sender'] = django_settings.RIETVELD_INCOMING_MAIL_ADDRESS\n else:\n raise\n except apiproxy_errors.DeadlineExceededError:\n # apiproxy_errors.DeadlineExceededError is raised when the\n # deadline of an API call is reached (e.g. for mail it's\n # something about 5 seconds). It's not the same as the lethal\n # runtime.DeadlineExeededError.\n attempts += 1\n if attempts >= 3:\n raise\n if attempts:\n logging.warning(\"Retried sending email %s times\", attempts)\n\n return msg","def create_message(self, sender, to, subject, message_text):\n message = MIMEText(message_text, 'html')\n message['to'] = str(to)\n message['from'] = str(sender)\n message['subject'] = str(subject)\n encoded_message = base64.urlsafe_b64encode(\n message.as_string().encode('utf-8')).decode('ascii')\n print(encoded_message, 'this is encoded_message')\n return {'raw': encoded_message}","def create_message(self, sender, to, subject, message_text):\n message = MIMEText(message_text, 'html')\n message['to'] = str(to)\n message['from'] = str(sender)\n message['subject'] = str(subject)\n encoded_message = base64.urlsafe_b64encode(\n message.as_string().encode('utf-8')).decode('ascii')\n print(encoded_message, 'this is encoded_message')\n return {'raw': encoded_message}","def build_message():\n outgoing_mail = Mail()\n outgoing_mail.from_email = Email(email_from_address, email_from_name)\n outgoing_mail.subject = subject\n personalization = Personalization()\n for recipient in email_to_addresses:\n personalization.add_to(Email(recipient))\n outgoing_mail.add_personalization(personalization)\n outgoing_mail.add_content(Content(\"text/plain\", str.join('\\n', _log)))\n outgoing_mail.add_content(Content(\"text/html\", \"<html><body> {} </body></html>\".format(str.join(' <br /> ', _log))))\n return outgoing_mail.get()","def test_notification_creation_email(self):\n mailhost = api.portal.get_tool('MailHost')\n self.assertEqual(len(mailhost.messages), 1)\n msg = message_from_string(mailhost.messages[0])\n\n self.assertEqual(msg['To'], BOARD_LIST_ADDRESS)\n self.assertEqual(\n msg['From'], 'EESTEC International <noreply@eestec.net>')\n self.assertEqual(\n msg['Subject'],\n '=?utf-8?q?=5BEVENTS=5D=5BCreated=5D_T=C3=A9st_event?=',\n )\n self.assertIn('a new Event has been created', msg.get_payload())\n self.assertIn('T=C3=A9st event', msg.get_payload())","def create_message(author, text):\n\n message = Message(author=author, text=text)\n\n db.session.add(message)\n db.session.commit()\n\n return message","def create_message(message_content, timestamp, username, channel, message_type):\n return Message.objects.create(\n message_content=message_content,\n datetime_start=timestamp_to_datetime(timestamp),\n username=username,\n typing=True,\n channel=channel,\n message_type=message_type\n )","def create_message(sender, to, subject, message_text, image_directory=None):\n message = MIMEMultipart()\n message['to'] = to if isinstance(to, str) else ','.join(to)\n if sender:\n message['from'] = sender\n message['subject'] = subject\n\n msg = MIMEText(message_text, 'html')\n message.attach(msg)\n\n if image_directory:\n for image_name in os.listdir(image_directory):\n with open(os.path.join(image_directory, image_name), 'rb') as img_data:\n content_type, encoding = mimetypes.guess_type(image_name)\n\n if content_type is None or encoding is not None:\n content_type = 'application/octet-stream'\n main_type, sub_type = content_type.split('/', 1)\n if main_type == 'image':\n msg = MIMEImage(img_data.read(), _subtype=sub_type)\n else:\n msg = MIMEBase(main_type, sub_type)\n msg.set_payload(img_data.read())\n\n msg.add_header('Content-Id', '<' + image_name.split('.')[0] + '>') # angle brackets are important\n message.attach(msg)\n\n # https://www.pronoy.in/2016/10/20/python-3-5-x-base64-encoding-3/\n return {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode('ascii')}","def create_next_message(self, **kwargs):\n message = self._builder.create_message(**kwargs)\n return message","def create_base_message(subject, msg=None):\n message = EmailMessage()\n message[\"From\"] = email_config.from_address\n message[\"To\"] = email_config.to_addresses\n message[\"Subject\"] = subject\n message.set_content(\"\\n\".join([\n 50 * \"_\",\n f\"Hostname: {gethostname()}\",\n f\"Time: {datetime.now().strftime(config.datetime_format)}\",\n f\"Log file: {LOGGER.log_file_path}\",\n 50 * \"_\",\n ]))\n # Add `msg` to the contents if it is not None\n if msg is not None:\n _append_content(message, msg)\n # Attach the log file if it is available\n if LOGGER.log_file_path is not None and config.email_attach_log_file:\n _attach_log_file(message)\n return message.as_string()","def build_hello_email():\n from_email = Email(\"test@example.com\")\n subject = \"Hello World from the SendGrid Python Library\"\n to_email = Email(\"test@example.com\")\n content = Content(\"text/plain\", \"some text here\")\n mail = Mail(from_email, subject, to_email, content)\n mail.personalizations[0].add_to(Email(\"test2@example.com\"))\n\n return mail.get()","def create_user_message(self, *args, **kwargs) -> UserMessage:\n \n raise NotImplementedError()","def create(cls, course_id, sender, to_option, subject, html_message, text_message=None):\r\n # automatically generate the stripped version of the text from the HTML markup:\r\n if text_message is None:\r\n text_message = html_to_text(html_message)\r\n\r\n # perform some validation here:\r\n if to_option not in TO_OPTIONS:\r\n fmt = 'Course email being sent to unrecognized to_option: \"{to_option}\" for \"{course}\", subject \"{subject}\"'\r\n msg = fmt.format(to_option=to_option, course=course_id, subject=subject)\r\n raise ValueError(msg)\r\n\r\n # create the task, then save it immediately:\r\n course_email = cls(\r\n course_id=course_id,\r\n sender=sender,\r\n to_option=to_option,\r\n subject=subject,\r\n html_message=html_message,\r\n text_message=text_message,\r\n )\r\n course_email.save_now()\r\n\r\n return course_email","def create_message(message_author, message_text):\n\n message = Message(message_author=message_author, message_text=message_text)\n\n db.session.add(message)\n db.session.commit()\n\n return message","def cmd_conversation_create(client, args):\n create_message = client.create_message(args.recipient, args.body)\n generate_output({'create_message': create_message})","def _message(self, recipient, connection, context=None):\n base_subject = '{{ event.calendar.course.name }} {{ event.title }}'\n if not self.event.get_documents(True):\n template_name = self.REQUEST_TEMPLATE\n subject = 'Got a {} study guide?'.format(base_subject)\n else:\n template_name = self.PUBLISH_TEMPLATE\n subject = '{} study guide'.format(base_subject)\n\n subject = Template(subject).render(context)\n body = get_template(template_name).render(context)\n\n return make_email_message(subject, body,\n make_display_email(\n self.sender_address,\n self.sender_name),\n recipient, connection)","def submit_message_from_message(message,body,by=None):\n if not by:\n by = Person.objects.get(name=\"(System)\")\n msg = Message.objects.create(\n by = by,\n subject = message.get('subject',''),\n frm = message.get('from',''),\n to = message.get('to',''),\n cc = message.get('cc',''),\n bcc = message.get('bcc',''),\n reply_to = message.get('reply_to',''),\n body = body,\n time = utc_from_string(message.get('date', ''))\n )\n return msg","def new_email(self, context, payload):\n\n access_token = util.get_access_token(context['headers'])\n url = util.get_url(context) + f\"messages/{payload['id']}\"\n response = util.rest(\"GET\", url, access_token)\n\n if response.status_code > 400:\n raise Exception(\"Error \", response.text)\n\n email_obj = json.loads(response.text)\n\n return GmailApi.get_email_data(email_obj)","def message_new(self, cr, uid, msg, custom_values=None, context=None):\n if custom_values is None: custom_values = {}\n\n desc = html2plaintext(msg.get('body')) if msg.get('body') else ''\n custom_values.update({\n 'name': msg.get('subject') or _(\"No Subject\"),\n 'description': desc,\n 'email_from': msg.get('from'),\n 'email_cc': msg.get('cc'),\n 'user_id': False,\n })\n if msg.get('priority') in dict(crm.AVAILABLE_PRIORITIES):\n custom_values['priority'] = msg.get('priority')\n return super(crm_lead, self).message_new(cr, uid, msg, custom_values=custom_values, context=context)","def get_message(self, email):\n\n message = MIMEText(self.message, 'html')\n\n message['Subject'] = self.subject\n message['From'] = self.from_\n message['To'] = email\n\n return message","def create_group_message(group_name,subject,message,status,createdby):\n query=\"INSERT INTO groupmails(group_name,subject,message,status,createdby)VALUES('{}','{}','{}','{}','{}')\".format(\n group_name,subject,message,status,createdby\n )\n cur.execute(query)","def create_message(message):\n return {\n \"id\": message.id,\n \"from\": message.sender,\n \"preview\": create_preview(message),\n \"subject\": message.subject,\n \"date\": message.date_created,\n }","def compose(self, msg, recipient):\n email = Email(msg, self, recipient)\n self.mailman.send(email)","def create_user_message(user, message):\n user_message = UserMessage(user=user, message=message)\n\n db.session.add(user_message)\n db.session.commit()\n\n return user_message","def build_email(self, email_from, email_to, subject, body, email_cc=None, email_bcc=None, reply_to=False,\n attachments=None, message_id=None, references=None, object_id=False, subtype='plain', headers=None,\n body_alternative=None, subtype_alternative='plain'):\n email_from = email_from or self._get_default_from_address()\n assert email_from, \"You must either provide a sender address explicitly or configure \"\\\n \"using the combintion of `mail.catchall.domain` and `mail.default.from` \"\\\n \"ICPs, in the server configuration file or with the \"\\\n \"--email-from startup parameter.\"\n\n # Note: we must force all strings to to 8-bit utf-8 when crafting message,\n # or use encode_header() for headers, which does it automatically.\n\n headers = headers or {} # need valid dict later\n email_cc = email_cc or []\n email_bcc = email_bcc or []\n body = body or u''\n\n email_body = ustr(body)\n email_text_part = MIMEText(email_body, _subtype=subtype, _charset='utf-8')\n msg = MIMEMultipart()\n\n if not message_id:\n if object_id:\n message_id = tools.generate_tracking_message_id(object_id)\n else:\n message_id = make_msgid()\n msg['Message-Id'] = encode_header(message_id)\n if references:\n msg['references'] = encode_header(references)\n msg['Subject'] = encode_header(subject)\n msg['From'] = encode_rfc2822_address_header(email_from)\n del msg['Reply-To']\n if reply_to:\n msg['Reply-To'] = encode_rfc2822_address_header(email_from) #self.smtp_user\n else:\n msg['Reply-To'] = msg['From']\n msg['To'] = encode_rfc2822_address_header(COMMASPACE.join(email_to))\n if email_cc:\n msg['Cc'] = encode_rfc2822_address_header(COMMASPACE.join(email_cc))\n if email_bcc:\n msg['Bcc'] = encode_rfc2822_address_header(COMMASPACE.join(email_bcc))\n msg['Date'] = formatdate()\n # Custom headers may override normal headers or provide additional ones\n for key, value in headers.items():\n msg[pycompat.to_text(ustr(key))] = encode_header(value)\n\n if subtype == 'html' and not body_alternative:\n # Always provide alternative text body ourselves if possible.\n text = html2text.html2text(email_body)\n alternative_part = MIMEMultipart(_subtype=\"alternative\")\n alternative_part.attach(MIMEText(text, _charset='utf-8', _subtype='plain'))\n alternative_part.attach(email_text_part)\n msg.attach(alternative_part)\n elif body_alternative:\n # Include both alternatives, as specified, within a multipart/alternative part\n alternative_part = MIMEMultipart(_subtype=\"alternative\")\n body_alternative_ = ustr(body_alternative)\n alternative_body_part = MIMEText(body_alternative_, _subtype=subtype_alternative, _charset='utf-8')\n alternative_part.attach(alternative_body_part)\n alternative_part.attach(email_text_part)\n msg.attach(alternative_part)\n else:\n msg.attach(email_text_part)\n\n if attachments:\n for (fname, fcontent, mime) in attachments:\n filename_rfc2047 = encode_header_param(fname)\n if mime and '/' in mime:\n maintype, subtype = mime.split('/', 1)\n part = MIMEBase(maintype, subtype)\n else:\n part = MIMEBase('application', \"octet-stream\")\n\n # The default RFC2231 encoding of Message.add_header() works in Thunderbird but not GMail\n # so we fix it by using RFC2047 encoding for the filename instead.\n part.set_param('name', filename_rfc2047)\n part.add_header('Content-Disposition', 'attachment', filename=filename_rfc2047)\n\n part.set_payload(fcontent)\n encoders.encode_base64(part)\n msg.attach(part)\n return msg","def CreateMessageWithAttachment(sender, to, subject, message_text, file_dir,\n filename):\n message = MIMEMultipart()\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n\n msg = MIMEText(message_text)\n message.attach(msg)\n\n path = os.path.join(file_dir, filename)\n content_type, encoding = mimetypes.guess_type(path)\n\n main_type, sub_type = content_type.split('/', 1)\n fp = open(path, 'rb')\n msg = MIMEBase(main_type, sub_type)\n msg.set_payload(fp.read())\n\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\n encoders.encode_base64(msg)\n\n fp.close()\n\n message.attach(msg)\n\n return {'raw': base64.urlsafe_b64encode(bytes(message.as_string(), encoding='utf-8')).decode()}","def _construct_message(self):\n self.message[\"text\"] = \"\"\n if self.from_:\n self.message[\"text\"] += \"From: \" + self.from_ + \"\\n\"\n if self.subject:\n self.message[\"text\"] += \"Subject: \" + self.subject + \"\\n\"\n\n self.message[\"text\"] += self.body\n self._add_attachments()","def generate_withno_attachement(sender, recipient, subject, body):\n # Basic Email formatting\n message = email.message.EmailMessage()\n message[\"From\"] = sender\n message[\"To\"] = recipient\n message[\"Subject\"] = subject\n message.set_content(body)\n return message","def send_created_email(self):\n if settings.NOTIFY_NEW_REG:\n to = settings.NOTIFY_NEW_REG\n message = \"\"\"\\\nGreetings,<br><br>\n\nA new vehicle registration has been submitted by %s.<br><br>\n\nGo here to view or edit the request: <br>\n<a href=\"%s\">%s</a>\n<br><br>\nSincerely,<br><br>\nThe Janelia Parking Permit Program\n \"\"\" % (self.user_display_name(), self.get_edit_url(True), self.get_edit_url(True))\n subject = 'A new parking permit request has been entered'\n from_email = 'parkingpermit-donotreply@janelia.hhmi.org'\n text_content = re.sub(r'<[^>]+>','',message)\n html_content = message\n msg = EmailMultiAlternatives(subject, text_content, from_email, to)\n msg.attach_alternative(html_content, \"text/html\")\n msg.send()","def format_message(to_email, to_name):\r\n\r\n message = MIMEMultipart(\"alternative\")\r\n message[\"From\"] = my_email\r\n message[\"To\"] = to_email\r\n\r\n # This message is formatted in HTML since it's the only way to embed links\r\n with open('message.html', 'r') as f:\r\n message[\"Subject\"] = f.readline().split('Subject: ', 1)[-1]\r\n raw = f.read() % to_name\r\n content = MIMEText(raw, \"html\")\r\n message.attach(content)\r\n return message","def action_create_mail_messages(self):\n self.check_recipients()\n self.check_message()\n messages = self.env['mail.message']\n for recipient in self.recipient_ids:\n messages |= recipient._create_mail_message()\n return messages","def get_email_message(self, subject, body, sender, recipients, attachment=None): # pylint: disable=too-many-arguments\n msg = {}\n source = {}\n data = {}\n\n data[\"body\"] = body\n data[\"from\"] = sender\n data[\"subject\"] = subject\n data[\"type\"] = \"cla-email-event\"\n if isinstance(recipients, str):\n data[\"recipients\"] = [recipients]\n else:\n data[\"recipients\"] = recipients\n # Added MailChip/Mandrill support by setting the template and adding\n # email body to the parameters list under the BODY attribute\n data[\"template_name\"] = \"EasyCLA System Email Template\"\n data[\"parameters\"] = {\n \"BODY\": body\n }\n\n msg[\"data\"] = data\n\n source[\"client_id\"] = \"easycla-service\"\n source[\"description\"] = \"EasyCLA Service\"\n source[\"name\"] = \"EasyCLA Service\"\n msg[\"source_id\"] = source\n\n msg[\"id\"] = str(uuid.uuid4())\n msg[\"type\"] = \"cla-email-event\"\n msg[\"version\"] = \"0.1.0\"\n json_string = json.dumps(msg)\n # cla.log.debug(f'Email JSON: {json_string}')\n return json_string","def rpc_campaign_message_new(self, campaign_id, email_id, target_email, company_name, first_name, last_name):\n\t\tsession = db_manager.Session()\n\t\tmessage = db_models.Message()\n\t\tmessage.id = email_id\n\t\tmessage.campaign_id = campaign_id\n\t\tmessage.target_email = target_email\n\t\tmessage.company_name = company_name\n\t\tmessage.first_name = first_name\n\t\tmessage.last_name = last_name\n\t\tsession.add(message)\n\t\tsession.commit()\n\t\tsession.close()\n\t\treturn","def makeMessage( name, *structure ):\n return X12Message( name, *structure )","def create_user_message(user_id, message_id):\n user_message = UserMessage(user_id=user_id, message_id=message_id)\n\n db.session.add(user_message)\n db.session.commit()\n\n return user_message","def emailMessage(subjectTitle, recipientEmail, bodyMessage, attachmentName = None, attachmentFilePath = None):\n msg = Message(\n subjectTitle,\n sender = os.getenv(tag+'email',base_config['email']) \n )\n for email in recipientEmail: \n msg.add_recipient(email)\n\n msg.body = bodyMessage\n\n if attachmentName is not None and attachmentFilePath is not None:\n with app.open_resource(attachmentFilePath) as fp:\n msg.attach(attachmentName, \"text/plain\", fp.read())\n\n mail.send(msg)","def build_message(self, recipient_email):\n\t\tmessage = self.queue_doc.message\n\t\tif not message:\n\t\t\treturn \"\"\n\n\t\tmessage = message.replace(\n\t\t\tself.message_placeholder(\"tracker\"), self.get_tracker_str(recipient_email)\n\t\t)\n\t\tmessage = message.replace(\n\t\t\tself.message_placeholder(\"unsubscribe_url\"), self.get_unsubscribe_str(recipient_email)\n\t\t)\n\t\tmessage = message.replace(self.message_placeholder(\"cc\"), self.get_receivers_str())\n\t\tmessage = message.replace(\n\t\t\tself.message_placeholder(\"recipient\"), self.get_recipient_str(recipient_email)\n\t\t)\n\t\tmessage = self.include_attachments(message)\n\t\treturn message","def create_chat_message(self, author, message):\n\n return ChatMessage.objects.create(conversation=self.conversation,\n author=author,\n message=message)","def get_sample_message(self):\n message = MailgunMessage(self.bob, self.alice, \"Test Subject\", body_text=\"this is a test\")\n message.add_to(self.frank)\n message.add_to(self.bob)\n message.add_cc(self.frank)\n message.add_cc(self.alice)\n message.add_cc(self.bob)\n message.add_bcc(self.bob)\n message.add_bcc(self.alice)\n message.add_bcc(self.frank)\n return message","def _create_message(self, data, channel):\n if data['type'] != 'message':\n logging.info(\"Skipping message of type `%s'.\", data['type'])\n return\n\n logging.debug('Message data: %s', json.dumps(data))\n\n try:\n user = self.q(o.User).\\\n filter(o.User.slackid == data['user']).one()\n except KeyError:\n user = self.q(o.User).\\\n filter(o.User.slackid == data['comment']['user']).one()\n\n if not data['text'].strip():\n logging.info(\"Skipping message from `%s' since it's empty\",\n user.name)\n return\n\n message = o.Message(data)\n message.channel = channel\n message.user = user\n\n if data.get('is_starred'):\n message.is_starred = True\n\n if 'reactions' in data:\n for reaction_data in data['reactions']:\n message.reactions.append(o.Reaction(reaction_data))\n\n if data.get('subtype') == 'file_share':\n self._file_data(message, data['file'], data['file']['is_external'])\n elif data.get('subtype') == 'pinned_item':\n if data.get('attachments'):\n self._att_data(message, data['attachments'])\n elif data.get('item'):\n self._file_data(message, data['item'],\n data['item']['is_external'])\n elif data.get('attachments'):\n self._att_data(message, data['attachments'])\n\n self.session.add(message)","def prepare_message(self, body, priority=None, content_type=None,\n content_encoding=None, headers=None, properties=None):\n return amqp.Message(body, priority=priority,\n content_type=content_type,\n content_encoding=content_encoding,\n application_headers=headers,\n **properties)","def CreateMessageWithAttachment(\n sender, to, subject, message_text, file_dir, filename):\n message = MIMEMultipart()\n message['to'] = to\n message['from'] = sender\n message['subject'] = subject\n\n msg = MIMEText(message_text)\n message.attach(msg)\n\n path = os.path.join(file_dir, filename)\n content_type, encoding = mimetypes.guess_type(path)\n\n if content_type is None or encoding is not None:\n content_type = 'application/octet-stream'\n main_type, sub_type = content_type.split('/', 1)\n if main_type == 'text':\n fp = open(path, 'rb')\n msg = MIMEText(fp.read(), _subtype=sub_type)\n fp.close()\n elif main_type == 'image':\n fp = open(path, 'rb')\n msg = MIMEImage(fp.read(), _subtype=sub_type)\n fp.close()\n elif main_type == 'audio':\n fp = open(path, 'rb')\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\n fp.close()\n else:\n fp = open(path, 'rb')\n msg = MIMEBase(main_type, sub_type)\n msg.set_payload(fp.read())\n fp.close()\n\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\n message.attach(msg)\n\n return {'raw': base64.urlsafe_b64encode(message.as_string())}","def create_message(self, ticket_number, author, body, note=True):\n data = {\n 'author': author,\n 'body': body,\n 'note': note\n }\n url = ('https://api.groovehq.com/v1/tickets/{}/messages'\n .format(ticket_number))\n resp = self._session.post(url, json=data)\n\n result = resp.json()\n new_url = ret['message']['href']\n nums = re.findall(r'\\d+', new_url)\n\n if len(nums) > 0:\n return nums[-1]","def construct_message(self):\n msg_type = self.msg_type\n if msg_type == \"PUBMSG\":\n msg_type = \"PRIVMSG\"\n ret = \"{} {}\".format(msg_type, self.target)\n if self.content:\n ret += \" :{}\".format(self.content)\n return ret + \"\\r\\n\"","def new_message(self, body=''):\r\n m = self.message_class(self, body)\r\n m.queue = self\r\n return m","def draft_message(self, text=None, template_path=None, template_args=None):\n self.message['From'] = self.sender\n self.message['To'] = '; '.join(self.destinations)\n self.message['BCC'] = '; '.join(self.bcc)\n self.message['CC'] = '; '.join(self.cc)\n self.message['Subject'] = self.subject\n\n # check if email template is used\n if template_path:\n text = self.body_template(template_path)\n text = text.format(**template_args)\n\n # attach text part of message\n self.message.attach(MIMEText(text))\n\n # return self to encourage method chaining\n return self","def send(self):\n # Validate message\n if self._text_body is None and self._html_body is None:\n raise Exception(\"Error! Must specify at least one body type (HTML or Text)\")\n if len(self._to) == 0:\n raise Exception(\"Must specify at least one recipient\")\n\n # Create the message part\n if self._text_body is not None and self._html_body is None:\n msg = MIMEText(self._text_body, \"plain\")\n elif self._text_body is None and self._html_body is not None:\n msg = MIMEText(self._html_body, \"html\")\n else:\n msg = MIMEMultipart(\"alternative\")\n msg.attach(MIMEText(self._text_body, \"plain\"))\n msg.attach(MIMEText(self._html_body, \"html\"))\n # Add attachments, if any\n if len(self._attach) != 0:\n tmpmsg = msg\n msg = MIMEMultipart()\n msg.attach(tmpmsg)\n for fname,attachname in self._attach:\n if not os.path.exists(fname):\n print \"File '%s' does not exist. Not attaching to email.\" % fname\n continue\n if not os.path.isfile(fname):\n print \"Attachment '%s' is not a file. Not attaching to email.\" % fname\n continue\n # Guess at encoding type\n ctype, encoding = mimetypes.guess_type(fname)\n if ctype is None or encoding is not None:\n # No guess could be made so use a binary type.\n ctype = 'application/octet-stream'\n maintype, subtype = ctype.split('/', 1)\n if maintype == 'text':\n fp = open(fname)\n attach = MIMEText(fp.read(), _subtype=subtype)\n fp.close()\n elif maintype == 'image':\n fp = open(fname, 'rb')\n attach = MIMEImage(fp.read(), _subtype=subtype)\n fp.close()\n elif maintype == 'audio':\n fp = open(fname, 'rb')\n attach = MIMEAudio(fp.read(), _subtype=subtype)\n fp.close()\n else:\n fp = open(fname, 'rb')\n attach = MIMEBase(maintype, subtype)\n attach.set_payload(fp.read())\n fp.close()\n # Encode the payload using Base64\n encoders.encode_base64(attach)\n # Set the filename parameter\n if attachname is None:\n filename = os.path.basename(fname)\n else:\n filename = attachname\n attach.add_header('Content-Disposition', 'attachment', filename=filename)\n msg.attach(attach)\n # Some header stuff\n msg['Subject'] = self._subject\n msg['From'] = self._from\n msg['To'] = \", \".join(self._to)\n if self._reply_to:\n msg['Reply-To'] = self._reply_to\n if len(self._cc) > 0:\n msg['Cc'] = \", \".join(self._cc)\n if len(self._bcc) > 0:\n msg['Bcc'] = \", \".join(self._bcc)\n msg.preamble = \"You need a MIME enabled mail reader to see this message\"\n # Send message\n msg = msg.as_string()\n server = None\n if self._smtp_ssl:\n server = smtplib.SMTP_SSL(host=self._smtp_server,\n port=self._smtp_port)\n else:\n server = smtplib.SMTP(host=self._smtp_server, port=self._smtp_port)\n if self._smtp_user:\n server.login(self._smtp_user, self._smtp_password)\n server.sendmail(self._from, self._to, msg)\n server.quit()","def _create_message(self, msg):\n head = msg[\"head\"]\n body = msg[\"body\"]\n body = body.format(**self.data)\n length = len(body)\n head = head.format(length=length, **self.data)\n return head + body","def create_email(username, provider):\n print(f\"Your new email is {username}@{provider}.com\")","def create_multipart_message(\n sender: str, recipients: list, title: str, text: str = None, html_text: str = None, attachments: list = None) \\\n -> MIMEMultipart:\n multipart_content_subtype = 'alternative' if text and html_text else 'mixed'\n msg = MIMEMultipart(multipart_content_subtype)\n msg['Subject'] = title\n msg['From'] = sender\n msg['To'] = ', '.join(recipients)\n\n # Record the MIME types of both parts - text/plain and text/html.\n # According to RFC 2046, the last part of a multipart message, in this case the HTML message, is best and preferred.\n if text:\n part = MIMEText(text, 'plain')\n msg.attach(part)\n if html_text:\n part = MIMEText(html_text, 'html')\n msg.attach(part)\n\n # Add attachments\n for attachment in attachments or []:\n with open(attachment, 'rb') as f:\n part = MIMEApplication(f.read())\n part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(attachment))\n msg.attach(part)\n\n return msg","def send_email(self, message):\n pass","def createMessageWithAttachment(\r\n sender, to, subject, msgHtml, msgPlain, attachmentFile):\r\n message = MIMEMultipart('mixed')\r\n message['to'] = to\r\n message['from'] = sender\r\n message['subject'] = subject\r\n\r\n messageA = MIMEMultipart('alternative')\r\n messageR = MIMEMultipart('related')\r\n\r\n messageR.attach(MIMEText(msgHtml, 'html'))\r\n messageA.attach(MIMEText(msgPlain, 'plain'))\r\n messageA.attach(messageR)\r\n\r\n message.attach(messageA)\r\n\r\n print(\"create_message_with_attachment: file: %s\" % attachmentFile)\r\n content_type, encoding = mimetypes.guess_type(attachmentFile)\r\n\r\n if content_type is None or encoding is not None:\r\n content_type = 'application/octet-stream'\r\n main_type, sub_type = content_type.split('/', 1)\r\n if main_type == 'text':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEText(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n elif main_type == 'image':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEImage(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n elif main_type == 'audio':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n else:\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEBase(main_type, sub_type)\r\n msg.set_payload(fp.read())\r\n fp.close()\r\n filename = os.path.basename(attachmentFile)\r\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\r\n message.attach(msg)\r\n\r\n return {'raw': base64.urlsafe_b64encode((message.as_string()).encode('UTF-8')).decode('ascii')}","def createMessageWithAttachment(sender, to, subject, msgHtml, msgPlain, attachmentFile):\r\n message = MIMEMultipart('mixed')\r\n message['to'] = to\r\n message['from'] = sender\r\n message['subject'] = subject\r\n\r\n messageA = MIMEMultipart('alternative')\r\n messageR = MIMEMultipart('related')\r\n\r\n messageR.attach(MIMEText(msgHtml, 'html'))\r\n messageA.attach(MIMEText(msgPlain, 'plain'))\r\n messageA.attach(messageR)\r\n\r\n message.attach(messageA)\r\n\r\n print(\"create_message_with_attachment: file: %s\" % attachmentFile)\r\n content_type, encoding = mimetypes.guess_type(attachmentFile)\r\n\r\n if content_type is None or encoding is not None:\r\n content_type = 'application/octet-stream'\r\n main_type, sub_type = content_type.split('/', 1)\r\n if main_type == 'text':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEText(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n elif main_type == 'image':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEImage(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n elif main_type == 'audio':\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\r\n fp.close()\r\n else:\r\n fp = open(attachmentFile, 'rb')\r\n msg = MIMEBase(main_type, sub_type)\r\n msg.set_payload(fp.read())\r\n fp.close()\r\n filename = os.path.basename(attachmentFile)\r\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\r\n message.attach(msg)\r\n\r\n return {'raw': base64.urlsafe_b64encode(message.as_string())}","def replyMessage(_email, _name):\n\n _mailer = app.config['MAIL_USERNAME']\n mesg = Message(\"Message Received\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[_email])\n mesg.body = f'''Hello {_name},\nThe message you sent to Randy has been received. \nRandy will contact you within 24 hours.\nThank you.\n\nRegards,\nRandy\n\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\n'''\n mail.send(mesg)\n return 'OK'","def create_message(self,message_information):\n\n #create the message\n if message_information['service'] == 'whatsapp':\n #The details of the message sent is saved here\n message = self.client.messages.create(\n body='Your order of {food} from the {store_name} store is ready. Additional Information: {addit_info}'.format(**message_information),\n from_='whatsapp:{sender_number}'.format(**self.config),\n to='whatsapp:{mobile}'.format(**message_information)\n )\n #Set the ready state to waiting for collection\n #self.firebase.db.child('orders').child('{store_name}'.format(**message_information)).child('{order_id}'.format(**message_information)).update({\"ready\":\"waiting for collection\"})\n self.firebase.update([\"orders\", STORE_NAME, message_information[\"order_id\"]], {\"ready\": \"waiting for collection\"})","def _copy_message(self, message):\r\n gmsg = aeemail.EmailMessage(sender=message.from_email,\r\n to=message.to,\r\n subject=message.subject,\r\n body=message.body)\r\n if message.extra_headers.get('Reply-To', None):\r\n gmsg.reply_to = message.extra_headers['Reply-To']\r\n if message.cc:\r\n gmsg.cc = list(message.cc)\r\n if message.bcc:\r\n gmsg.bcc = list(message.bcc)\r\n if message.attachments:\r\n # Must be populated with (filename, filecontents) tuples.\r\n attachments = []\r\n for attachment in message.attachments:\r\n if isinstance(attachment, MIMEBase):\r\n attachments.append((attachment.get_filename(),\r\n attachment.get_payload(decode=True)))\r\n else:\r\n attachments.append((attachment[0], attachment[1]))\r\n gmsg.attachments = attachments\r\n # Look for HTML alternative content.\r\n if isinstance(message, EmailMultiAlternatives):\r\n for content, mimetype in message.alternatives:\r\n if mimetype == 'text/html':\r\n gmsg.html = content\r\n break\r\n return gmsg","def create_email(_from, _to, _subj, _body, files):\r\n msg = MIMEMultipart()\r\n msg['From'] = _from\r\n msg['To'] = _to\r\n msg['Subject'] = _subj\r\n msg.attach(MIMEText(_body, 'plain'))\r\n\r\n if files:\r\n for file in files:\r\n part = MIMEBase('application', 'octet-stream')\r\n part.set_payload(open(file, 'rb').read())\r\n encoders.encode_base64(part)\r\n part.add_header('Content-Disposition', 'attachment; filename=' + os.path.basename(file))\r\n msg.attach(part)\r\n\r\n return msg","def sendEmail(_name, _email, _body):\n\n _mailer = app.config['MAIL_USERNAME']\n msg = Message(\"Contact Form\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\n msg.body = f'''{_body}\n\n\nSender's Name: {_name}\nSender's Email: {_email}\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\n'''\n mail.send(msg)\n return 'OK'","def make_email(to_list=None, cc_list=None, bcc_list=None, from_address=None, reply_address=None, attachments=None,\n subject=None, body=None, template=None, html=False):\n if template is not None and (subject is not None or body is not None):\n raise ValueError('Only subject/body or template can be passed')\n\n if template:\n subject = template.get_subject()\n body = template.get_body()\n if config.DEBUG and '\\n' in subject:\n raise ValueError('Email subject contains linebreaks')\n subject = re.sub(r'\\s+', ' ', subject)\n if to_list is None:\n to_list = set()\n if cc_list is None:\n cc_list = set()\n if bcc_list is None:\n bcc_list = set()\n to_list = {to_list} if isinstance(to_list, str) else to_list\n cc_list = {cc_list} if isinstance(cc_list, str) else cc_list\n bcc_list = {bcc_list} if isinstance(bcc_list, str) else bcc_list\n reply_address = {reply_address} if (isinstance(reply_address, str) and reply_address) else (reply_address or set())\n return {\n 'to': set(to_list),\n 'cc': set(cc_list),\n 'bcc': set(bcc_list),\n 'from': from_address or config.NO_REPLY_EMAIL,\n 'reply_to': set(reply_address),\n 'attachments': attachments or [],\n 'subject': subject.strip(),\n 'body': body.strip(),\n 'html': html,\n }","def create_sent_email(self, *args, **kwargs):\n receiver = kwargs['receiver']\n sender = kwargs['sender']\n user = kwargs['user']\n body = kwargs['body']\n subject = kwargs['subject']\n if receiver and sender and subject and body:\n sent_email = SentEmail()\n sent_email.receiver = receiver\n sent_email.subject = subject\n sent_email.sender = sender\n sent_email.status = 'sent'\n sent_email.user = user\n sent_email.body = body\n sent_email.save()\n return True\n else:\n return False","def create(\n cls,\n recipient_id: str,\n recipient_email: str,\n sender_id: str,\n sender_email: str,\n intent: str,\n subject: str,\n html_body: str,\n sent_datetime: datetime.datetime\n ) -> None:\n instance_id = cls._generate_id(intent)\n email_model_instance = cls(\n id=instance_id, recipient_id=recipient_id,\n recipient_email=recipient_email, sender_id=sender_id,\n sender_email=sender_email, intent=intent, subject=subject,\n html_body=html_body, sent_datetime=sent_datetime)\n\n email_model_instance.update_timestamps()\n email_model_instance.put()","def make_and_mail(receiver, subject, body):\n emailbody = MIMEText(body, 'html')\n msg = MIMEMultipart('alternative')\n msg['From'] = SENDER\n msg['To'] = receiver\n msg['Subject'] = subject\n msg.attach(emailbody)\n #pylint: disable=invalid-name\n try:\n s = smtplib.SMTP('smtp.gmail.com', 587)\n s.starttls()\n s.login(YOUPAPER_EMAIL, YOUPAPER_PASSWORD)\n s.sendmail(SENDER, receiver, msg.as_string())\n s.quit()\n return 1 #returns 1 if success\n except smtplib.SMTPException:\n return 0 #returns 0 if failure","def post(self, request):\n # get message from request\n message = request.POST.get('message')\n # create message\n\n ChatMessage.objects.create(\n message=message, _from=request.user, _to=request.user.client.trainer.user)\n # return response\n return HttpResponse('success')","def send_feedback_message_email(recipient_id, feedback_messages):\n email_subject_template = (\n 'You\\'ve received %s new message%s on your explorations')\n\n email_body_template = (\n 'Hi %s,<br>'\n '<br>'\n 'You\\'ve received %s new message%s on your Oppia explorations:<br>'\n '<ul>%s</ul>'\n 'You can view and reply to your messages from your '\n '<a href=\"https://www.oppia.org/creator_dashboard\">dashboard</a>.'\n '<br>'\n '<br>Thanks, and happy teaching!<br>'\n '<br>'\n 'Best wishes,<br>'\n 'The Oppia Team<br>'\n '<br>%s')\n\n if not feconf.CAN_SEND_EMAILS:\n log_new_error('This app cannot send emails to users.')\n return\n\n if not feconf.CAN_SEND_FEEDBACK_MESSAGE_EMAILS:\n log_new_error('This app cannot send feedback message emails to users.')\n return\n\n if not feedback_messages:\n return\n\n recipient_user_settings = user_services.get_user_settings(recipient_id)\n\n messages_html = ''\n count_messages = 0\n for exp_id, reference in feedback_messages.iteritems():\n messages_html += (\n '<li><a href=\"https://www.oppia.org/create/%s#/feedback\">'\n '%s</a>:<br><ul>' % (exp_id, reference['title']))\n for message in reference['messages']:\n messages_html += ('<li>%s<br></li>' % message)\n count_messages += 1\n messages_html += '</ul></li>'\n\n email_subject = email_subject_template % (\n (count_messages, 's') if count_messages > 1 else ('a', ''))\n\n email_body = email_body_template % (\n recipient_user_settings.username, count_messages if count_messages > 1\n else 'a', 's' if count_messages > 1 else '', messages_html,\n EMAIL_FOOTER.value)\n\n _send_email(\n recipient_id, feconf.SYSTEM_COMMITTER_ID,\n feconf.EMAIL_INTENT_FEEDBACK_MESSAGE_NOTIFICATION,\n email_subject, email_body, feconf.NOREPLY_EMAIL_ADDRESS)","def send_email(to, subject, body, attachment=None):\n outlook = win32.Dispatch('outlook.application')\n new_mail = outlook.CreateItem(0)\n new_mail.Subject = subject\n new_mail.HTMLBody = body\n new_mail.To = to\n\n if attachment:\n new_mail.Attachments.Add(attachment)\n\n new_mail.Send()","def create_and_deliver(self, **kwargs: Any) -> Awaitable[None]:\n\n msg = self.create_message(**kwargs)\n return self.deliver(msg)","def new_message(self,\n intent=\"\",\n message=\"\",\n type=None,\n not_handled=False,\n time_stamp=None):\n self.messages.append(Message(api_key=self.api_key,\n platform=self.platform,\n version=self.version,\n user_id=self.user_id,\n intent=intent,\n message=message,\n type=type,\n not_handled=not_handled,\n time_stamp=time_stamp))\n return self.messages[-1]","def _create_msg(self, tr_id, payload, confirm, expire_time, encoding):\n tmp = [\"<SSAP_message><transaction_type>INSERT</transaction_type>\",\n \"<message_type>REQUEST</message_type>\"]\n tmp.extend([\"<transaction_id>\", str(tr_id), \"</transaction_id>\"])\n tmp.extend([\"<node_id>\", str(self.node_id), \"</node_id>\"])\n tmp.extend([\"<space_id>\", str(self.targetSS), \"</space_id>\"])\n tmp.extend(['<parameter name=\"insert_graph\" encoding=\"%s\">' % encoding.upper(),\n str(payload), \"</parameter>\"])\n tmp.extend(['<parameter name = \"confirm\">',\n str(confirm).upper(),\n \"</parameter>\",\n \"</SSAP_message>\"])\n return \"\".join(tmp)","def test_post_success_creates_message(self):\n sender, recipient = UserFactory(), UserFactory()\n\n data = {\n 'senderId': sender.id,\n 'recipientId': recipient.id,\n 'text': 'Hello World!',\n }\n\n response = self.client.post(\n reverse('messages:list'),\n content_type='application/json',\n data=data,\n )\n actual_message = Message.objects.get()\n self.assertEqual(sender.id, actual_message.sender.id)\n self.assertEqual(recipient.id, actual_message.recipient.id)\n self.assertEqual(data['text'], actual_message.text)","def send_msg(self, body, who, subject=None, **kwargs):\n\n # ============================================================\n # Parse and bail out if needed\n # ============================================================\n\n self._parse_who(who)\n\n if not self._ensure_recipients_exist():\n return\n\n # Kwargs\n attachment = kwargs.get('attachment', None)\n disable_email = kwargs.get('disable_email', False)\n disable_sms = kwargs.get('disable_sms', False)\n\n if not self._ensure_attachment_exists(attachment):\n return\n\n for b, n in zip([disable_email, disable_sms], ['disable_email', 'disable_sms']):\n if not isinstance(b, bool):\n msg = f'\\'{n}\\' must be boolean but you gave type {type(b)}'\n raise TypeError(msg)\n\n # ============================================================\n # Main\n # ============================================================\n\n with self._setup_smtp_server() as sess:\n\n # Create msg object\n msg = EmailMessage()\n\n # Personalize the template\n body_from_template = self.template.substitute(BODY=body)\n\n # Set msg parameters;\n # Note we will assign msg['To'] below when iterating over email addresses\n msg['From'] = self.sender_address\n msg['Subject'] = subject.upper() if isinstance(subject, str) else None\n\n # Copy outgoing emails to cc list\n if isinstance(self.cc_email_list, list):\n if len(self.cc_email_list) > 0:\n msg['CC'] = ','.join(self.cc_email_list)\n\n # Base text message\n msg.set_content(body_from_template)\n\n # HTML version\n body_html = re.sub(r'[\\n]', '<br>', body_from_template) # Replace /n with <br>\n logo_cid = make_msgid()\n msg.add_alternative(\"\"\"\\\n <html>\n <head></head>\n <body>\n <p>\"\"\" + body_html + '</p>' + \"\"\"\n <a href=\"https://www.liveline.tech\">\n <img src=\"cid:{logo_cid}\" />\n </a>\n </body>\n </html>\n \"\"\".format(logo_cid=logo_cid[1:-1]), subtype='html')\n\n # Add logo to the HTML version\n if EMAIL_SIGNATURE_LOGO_FILE is not None:\n t = root / EMAIL_SIGNATURE_LOGO_FILE\n if t.exists():\n with open(t, 'rb') as img:\n r = img.read()\n # noinspection PyUnresolvedReferences\n msg.get_payload()[1].add_related(r, 'image', 'png', cid=logo_cid)\n\n # Optionally attach a file\n # First use mimetypes to try and guess content type based on file extension:\n if attachment is not None:\n attachment = Path(attachment)\n ctype, encoding = mimetypes.guess_type(str(attachment))\n if ctype is None or encoding is not None:\n # No guess could be made, or the file is encoded (compressed), so\n # use a generic bag-of-bits type.\n ctype = 'application/octet-stream'\n maintype, subtype = ctype.split('/', 1)\n maintype += f'; name=\"{attachment.name}\"'\n with open(attachment, 'rb') as file:\n r = file.read()\n msg.add_attachment(r, maintype=maintype, subtype=subtype)\n\n # ============================================================\n # Email\n # ============================================================\n\n # For each email & phone in current lists, send messages\n if not disable_email:\n for e in self.current_email_list:\n\n # Console out\n stdout_msg = f'COMMUNICATOR MESSAGE: Sending email to: '\n fancy_print(stdout_msg, fg=COMMUNICATOR_MSG_COLOR, end='')\n fancy_print(e, fg='hlink')\n\n # Update msg 'To:' field\n if msg['To'] is not None:\n del msg['To']\n msg['To'] = e\n\n # # Make a local copy of what we are going to send... to a log file?\n # with open('outgoing.msg', 'wb') as f:\n # f.write(bytes(msg))\n\n try:\n sess.send_message(msg)\n except:\n stdout_msg = f'COMMUNICATOR WARNING: Failed sending email message'\n fancy_print(stdout_msg, fg=COMMUNICATOR_WARN_COLOR)\n\n # ============================================================\n # SMS\n # ============================================================\n\n if not disable_sms:\n for m in self.current_mobile_list:\n\n # Console out\n stdout_msg = f'COMMUNICATOR MESSAGE: Sending SMS message to: '\n fancy_print(stdout_msg, fg=COMMUNICATOR_MSG_COLOR, end='')\n fancy_print(m[0:3] + '.' + m[3:6] + '.' + m[6:10], fg='cerulean')\n\n any_ok = False\n candidates = list()\n\n # Try all the stubs!\n # We don't know the carrier name.\n # Assume the invalid addresses will get black-holed by the various carriers.\n for stub in self.sms_email_stubs:\n candidates.append(m + self.sms_email_stubs[stub])\n\n # Update msg 'To:' field\n if msg['To'] is not None:\n del msg['To']\n msg['To'] = candidates\n\n # # Make a local copy of what we are going to send... to a log file?\n # with open('outgoing.msg', 'wb') as f:\n # f.write(bytes(msg))\n\n try:\n sess.send_message(msg)\n any_ok = True\n except:\n pass\n\n if not any_ok:\n stdout_msg = f'COMMUNICATOR WARNING: Failed sending SMS message'\n fancy_print(stdout_msg, fg=COMMUNICATOR_WARN_COLOR)\n\n return","def create_email(user):\n if 'research' in user.get_domains():\n domain = 'research'\n else: domain = 'academic'\n subject = \"ECE/CIS Account Created\"\n helprequest = \"https://www.eecis.udel.edu/service\"\n \n message = \"Your ECE/CIS %s account has been created with the username: %s\\n\\n\" % (domain, user.username)\n message += \"Please do not reply to this message. If you need assistance with your account, please visit:\\n\"\n message += \"%s\\n\\n\" % helprequest\n message += \"-- EE/CIS Labstaff\\n\"\n\n send('account@eecis.udel.edu', 'ECE/CIS Account System', \\\n [user.email], subject, message, MAILHOST)","def build_message(self, subject, body, attachment=None):\n msg = MIMEMultipart()\n msg['From'] = self.src_addr\n msg['To'] = self.dest_addr\n msg['Subject'] = subject\n msg.attach(MIMEText(body, 'plain'))\n\n if attachment is not None:\n if os.path.exists(attachment):\n with open(attachment, 'rb') as a:\n part = MIMEBase('application', 'octet-stream')\n part.set_payload(a.read())\n encoders.encode_base64(part)\n part.add_header('Content-Disposition', 'attachment; filename= {}'.format(attachment))\n msg.attach(part)\n\n self.outbox.append(msg)","def br_msg_to(msg_body):\r\n msg = Message()\r\n msg.body = msg_body\r\n msg.set_metadata(\"performative\", \"inform\")\r\n return msg","def message_new(\n self, cr, uid, msg_dict, custom_values=None, context=None): \n if context is None:\n context = {}\n # prevent changes in context from \"bubbling up\" to calling methods\n local_context = dict(context)\n\n users_pool = self.pool.get('res.users')\n base_model = self.pool.get('ir.model.data')\n partner_model = self.pool.get('res.partner') \n\n # As the scheduler is run without language,\n # set the administrator's language\n if not local_context.get('lang'):\n user = users_pool.browse(cr, uid, uid, context=local_context)\n local_context['lang'] = user.partner_id.lang\n\n if custom_values is None:\n custom_values = {}\n email_from = msg_dict.get('from', False)\n if email_from:\n custom_values['name'] = _(\"Received by email from %s\") % email_from\n email_date = msg_dict.get('date', False)\n if email_date:\n custom_values['date_invoice'] = email_date\n\n company_id = (\n ('force_company' in local_context\n and local_context['force_company']) or False)\n\n # Retrieve partner_id from message dictionary.\n # Partner might be:\n # 1. Supplier sending email (author_id in msg dict.)\n # 2. Partner receiving message (special partner setup to receive\n # email). Should be linked to the appropiate company in multi-\n # company databases.\n # 3. Dummy invoice partner.\n # Partner MUST be a supplier.\n\n # 1. Try author:\n supplier_partner_id = False\n author_id = (\n 'author_id' in msg_dict and msg_dict['author_id'] or False)\n if (author_id\n and self._is_partner_supplier(\n cr, uid, author_id, context=local_context)):\n supplier_partner_id = author_id\n\n # 2. Try recipients:\n # Unfortunately we have to do a new lookup on partner, because\n # the method message_process in mail_thread removes the partner_ids\n # already found, from the message dictionary:\n if not supplier_partner_id:\n s = ', '.join(\n [msg_dict.get(h)\n for h in ['to', 'cc'] if msg_dict.get(h)])\n for email_address in tools.email_split(s):\n partner_ids = self.get_partner_from_mail(\n cr, uid, email_address, company_id, force_supplier=True,\n context=local_context)\n if partner_ids:\n supplier_partner_id = partner_ids[0]\n break\n\n # 3. Try default partner for company (company might be False):\n if not supplier_partner_id:\n args = [('fetchmail_invoice_default', '=', True),]\n if company_id:\n args.append(('company_id', '=', company_id))\n default_ids = partner_model.search(\n cr, uid, args, context=local_context)\n if default_ids: # can be only one\n supplier_partner_id = default_ids[0]\n\n # We should have a supplier/partner by now....\n assert supplier_partner_id, _('No partner found to link invoice to')\n\n # Get company for supplier, if any. If present, should be the same\n # as company for fetchmail config, if present. If still no\n # company is found, use main company.\n supplier_record = partner_model.read(\n cr, uid, supplier_partner_id, ['company_id', 'supplier'],\n context=local_context)\n supplier_company_id = (\n supplier_record['company_id'] and supplier_record['company_id'][0]\n or False)\n if supplier_company_id:\n if company_id:\n assert company_id == supplier_company_id, (_(\n 'Supplier found not valid for company %d.') %\n company_id)\n else:\n company_id = supplier_company_id\n if not company_id:\n # Last resort, use main company\n company_id = base_model.get_object_reference( \n cr, uid, 'base', 'main_company')[1]\n \n # Now we should have a company, and we should use it for everything\n assert company_id, (_(\n 'All attempts to determine company for invoice failed'))\n local_context['force_company'] = company_id\n \n # Paranoid check\n assert supplier_record['supplier'], (_(\n 'Partner %d is not a supplier') % supplier_partner_id)\n\n # And we should have an account property\n # (read again, as company might have changed)\n supplier_record = partner_model.read(\n cr, uid, supplier_partner_id, ['property_account_payable_id'],\n context=local_context)\n assert supplier_record['property_account_payable_id'], (\n _('No account payable on partner %d.') % supplier_partner_id)\n\n # And we need some information in context as well\n local_context.update({\n 'company_id': company_id,\n 'type': 'in_invoice',\n })\n\n supplier = partner_model.browse(cr, uid, supplier_partner_id, context=local_context)\n\n journal_id = self.pool.get('account.invoice').default_get(cr, uid, ['journal_id'], context=local_context)['journal_id']\n if not journal_id:\n raise UserError(_('Please define an accounting sale journal for this company.'))\n\n custom_values.update({\n 'company_id': company_id,\n 'partner_id': supplier_partner_id,\n 'type': 'in_invoice',\n\n 'account_id': supplier.property_account_payable_id.id,\n 'journal_id': journal_id,\n })\n\n\n # custom_values.update(\n # self.onchange_partner_id(\n # cr, uid, [], 'in_invoice', supplier_partner_id,\n # company_id=company_id)['value'])\n\n # Create the resource\n res_id = super(account_invoice, self).message_new(\n cr, uid, msg_dict, custom_values=custom_values,\n context=local_context)\n return res_id","def _generate_email(email, name=None):\n result = {'email': email}\n if name:\n result['name'] = name\n return result","def post(self, request):\n # get message from request\n message = request.POST.get('message')\n # create message\n ChatMessage.objects.create(\n message=message, _from=request.user, _to=User.objects.get(pk=request.POST.get('user_id')))\n # return response\n return HttpResponse('success')","def create(cls, sender, recipient, body, timestamp=None):\n if timestamp is None:\n timestamp = datetime.datetime.utcnow()\n msg = cls(sender, recipient, body, timestamp)\n db.session.add(msg)\n\n try:\n db.session.commit()\n db.session.flush()\n return msg.id\n except BaseException as exc:\n db.session.rollback()\n raise exc","def create_message(id_user: int, message: str):\n # Create datetime of today at midnight\n today = datetime.date.today()\n today = today.strftime(\"%Y-%m-%d %H:%M:%S\")\n # Query to check if there is already a message for this user today\n mycursor.execute(f\"\"\"SELECT id_message\n FROM Daily_message\n WHERE date_message >= '{today}'\n AND id_user = {id_user}\n \"\"\")\n rowcount = mycursor.rowcount\n if rowcount == 1:\n # If there is already a message today, user can't add a new one\n return 'Impossible d\\'ajouter ce message. Il y a déjà un message aujourd\\'hui, veuillez le modifier.'\n else:\n # Create datetime of today at current time\n date_message = datetime.datetime.today()\n date_message = date_message.strftime(\"%Y/%m/%d %H:%M:%S\")\n columns_mess = 'id_user, text, date_message'\n # Add the message infos to the Daily_message table\n add_in_database((id_user, message, date_message), 'Daily_message', columns_mess)\n mydb.commit()\n # Get the id_message\n mycursor.execute(f\"\"\"SELECT id_message\n FROM Daily_message\n WHERE (id_user = {id_user})\n AND (date_message >= '{today}')\n \"\"\")\n infos = mycursor.fetchall()\n id_message = infos[0][0]\n # Fill emotion table for the new message\n create_emotion(id_message, message)\n return {'id_user': id_user, 'message': message}","def create_message_talk(msg_talk_as_str):\n msg_comps = msg_talk_as_str.split('\\n')\n from_id = msg_comps[1]\n origin_id = msg_comps[2]\n message_id = msg_comps[3]\n topics = msg_comps[4].split(',')\n data = msg_comps[5]\n return MessageTalk(from_id, origin_id, topics, data, message_id)","def create(self, data):\n\n\t\tmessage = data\n\t\tmessage[\"id\"] = self.count = self.count + 1\n\t\tself.messages.append(message)\n\n\t\treturn(message)","def send_email(self, to_address, subject, body, cc_recipients=[]):\n\n # Build and send message\n msg = Message(\n account=self.account,\n folder=self.account.sent,\n subject=subject,\n body= HTMLBody(body),\n to_recipients=[Mailbox(email_address=to_address)],\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\n )\n\n msg.send_and_save()\n print(\"Message to {} sent.\".format(to_address))","def _create_msg(self, tr_id, i_triples, i_type, r_triples, r_type, confirm):\n params = SSAP_UPDATE_PARAM_TEMPLATE % (str(i_type).upper(),\n str(i_triples),\n str(r_type).upper(),\n str(r_triples),\n str(confirm).upper())\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\n self.tr_type, str(tr_id), params)\n return tmp","def quick_email(self, send_to, subject, body, style=None):\n message = Message(body, style=style)\n\n self.send_message(message, send_to, subject)","def get_email():\n return Email(\n subject='[Messages] Integration Test',\n body='Conducting Integration Testing',\n attachments=str(TESTDIR.joinpath('file2.png')))"],"string":"[\n \"def createMessage( self, *args, **kw ):\\n return MailMessage( *args, **kw )\",\n \"def createMessage( self, *args, **kw ):\\n if not kw.has_key('charset'):\\n kw['charset'] = self.getOutputCharset()\\n kw['to_mail'] = 1\\n return MailServerBase.createMessage( self, *args, **kw )\",\n \"def _createEmail(self, address_to, message, emailSubject):\\r\\n\\t\\tfrom_email = Email(self.sender)\\r\\n\\t\\tto_email = To(address_to)\\r\\n\\t\\tsubject = emailSubject\\r\\n\\t\\tcontent = Content(\\\"text/plain\\\", message)\\r\\n\\t\\t#creates Mail object from sendgrid api\\r\\n\\t\\tmail = Mail(from_email, to_email, subject, content)\\r\\n\\t\\treturn mail\",\n \"def create_message(sender, to, subject, cc, message_text):\\n\\n email = \\\"\\\"\\n \\n for c in message_text:\\n email += c\\n \\n message = MIMEText(email)\\n message['to'] = to\\n message['cc'] = cc\\n message['from'] = sender\\n message['subject'] = subject\\n return {'raw': base64.urlsafe_b64encode(message.as_string())}\",\n \"def __create_message(sender, recipients, subject, message_text):\\n message = {\\n \\\"to\\\": recipients,\\n \\\"from_email\\\": sender,\\n \\\"subject\\\": subject,\\n \\\"html\\\": message_text,\\n }\\n\\n return message\",\n \"def _create_email(\\n to_field=\\\"to_user@test1.com\\\",\\n from_field=\\\"from_user@test2.com\\\",\\n subject=\\\"This is a test email\\\",\\n body=\\\"Almost empty text message\\\",\\n attachment=None,\\n maintype=None,\\n subtype=None,\\n):\\n msg = EmailMessage()\\n\\n msg['To'] = to_field\\n msg['From'] = from_field\\n msg['Subject'] = subject\\n msg.set_content(body)\\n\\n if attachment:\\n with open(attachment, 'rb') as fp:\\n attachment = fp.read()\\n\\n msg.add_attachment(attachment, maintype=maintype, subtype=subtype)\\n\\n email_message = email.message_from_bytes(\\n msg.as_bytes(),\\n policy=email.policy.default\\n )\\n\\n return email_message\",\n \"def create_message(sender, to, subject, message_text):\\r\\n message = MIMEText(message_text)\\r\\n message['to'] = to\\r\\n message['from'] = sender\\r\\n message['subject'] = subject\\r\\n raw = base64.urlsafe_b64encode(message.as_bytes())\\r\\n raw = raw.decode()\\r\\n body = {'raw': raw}\\r\\n return body\",\n \"def createMessage( self, *args, **kw ):\\n if not kw.has_key('charset'):\\n kw['charset'] = self.getInputCharset()\\n return MailServerBase.createMessage( self, *args, **kw )\",\n \"def make_message(self, mto, mbody=None, msubject=None, mtype=None,\\n mhtml=None, mfrom=None, mnick=None):\\n message = self.Message(sto=mto, stype=mtype, sfrom=mfrom)\\n message['body'] = mbody\\n message['subject'] = msubject\\n if mnick is not None:\\n message['nick'] = mnick\\n if mhtml is not None:\\n message['html']['body'] = mhtml\\n return message\",\n \"def CreateMessage(sender, to, subject, message_text):\\n message = MIMEText(message_text, 'html')\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}\",\n \"def create_message(sender, to, subject, message_text_html, message_text_plain):\\r\\n message = MIMEMultipart('alternative')\\r\\n message['to'] = to\\r\\n message['from'] = sender\\r\\n message['subject'] = subject\\r\\n message_html = MIMEText(message_text_html, 'html') # HTML version\\r\\n message_plain = MIMEText(message_text_plain) # plain text version\\r\\n message.attach(message_plain)\\r\\n message.attach(message_html)\\r\\n return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}\",\n \"def createMessage(self, sender: str, to: str, subject: str, message_text: str):\\n message = MIMEText(message_text)\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n raw_message = {'raw': base64.urlsafe_b64encode(message.as_bytes())}\\n raw_message['raw']=raw_message['raw'].decode('utf-8')\\n return raw_message\",\n \"def get_message(self, **kwargs):\\n message = Mail()\\n if \\\"from_email\\\" in kwargs:\\n sender = Email()\\n message_content = kwargs.get(\\\"message_content\\\", \\\"\\\")\\n sender.name = message_content.get(\\\"sender\\\", emailconf.DEFAULT_SENDER)\\n sender.email = kwargs.get(\\\"from_email\\\", emailconf.DEFAULT_SENDER_EMAIL)\\n message.from_email = sender\\n if \\\"subject\\\" in kwargs:\\n message.subject = kwargs.get(\\\"subject\\\", \\\"\\\")\\n if \\\"text\\\" in kwargs:\\n content = Content(\\\"text/plain\\\", kwargs.get(\\\"text\\\", \\\"\\\"))\\n message.add_content(content)\\n if \\\"html\\\" in kwargs:\\n content = Content(\\\"text/html\\\", kwargs.get(\\\"html\\\", \\\"\\\"))\\n message.add_content(content)\\n if \\\"category\\\" in kwargs:\\n category = Category(kwargs.get(\\\"category\\\", \\\"\\\"))\\n message.add_category(category)\\n\\n personalization = self.create_personalization(**kwargs)\\n if personalization:\\n message.add_personalization(personalization)\\n\\n return message.get()\",\n \"def create_message(text: str, room: str, creating_user: str, receiving_user: str, channel: models.PrivateChannel):\\n message = models.Message(\\n text=text,\\n creating_user=creating_user,\\n receiving_user=receiving_user,\\n channel_id=channel.id,\\n room=room\\n )\\n db.session.add(message)\\n db.session.commit()\",\n \"def create_message(self, subject, message, destination, origin = None):\\n msg = MIMEText(message)\\n if origin is not None:\\n msg['From'] = origin\\n else:\\n msg['From'] = self.origin\\n msg['Subject'] = subject\\n msg['To'] = destination\\n self.messages.append(msg)\",\n \"def create_email(sender, to, subject, message_text):\\n # This is intended to strip non-ascii chars in message_text\\n message_text = ''.join(filter(lambda x: x in printable, message_text))\\n \\n message = MIMEText(message_text)\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n return message.as_bytes()\",\n \"def _make_message(request, issue, message, comments=None, send_mail=False,\\n draft=None, in_reply_to=None):\\n attach_patch = request.POST.get(\\\"attach_patch\\\") == \\\"yes\\\"\\n template, context = _get_mail_template(request, issue, full_diff=attach_patch)\\n # Decide who should receive mail\\n my_email = db.Email(request.user.email())\\n to = ([db.Email(issue.owner.email())] +\\n issue.reviewers +\\n [db.Email(email) for email in issue.collaborator_emails()])\\n cc = issue.cc[:]\\n if django_settings.RIETVELD_INCOMING_MAIL_ADDRESS:\\n cc.append(db.Email(django_settings.RIETVELD_INCOMING_MAIL_ADDRESS))\\n reply_to = to + cc\\n if my_email in to and len(to) > 1: # send_mail() wants a non-empty to list\\n to.remove(my_email)\\n if my_email in cc:\\n cc.remove(my_email)\\n issue_id = issue.key.id()\\n subject = issue.mail_subject()\\n patch = None\\n if attach_patch:\\n subject = 'PATCH: ' + subject\\n if 'patch' in context:\\n patch = context['patch']\\n del context['patch']\\n if issue.num_messages:\\n subject = 'Re: ' + subject\\n if comments:\\n details = _get_draft_details(request, comments)\\n else:\\n details = ''\\n message = message.replace('\\\\r\\\\n', '\\\\n')\\n text = ((message.strip() + '\\\\n\\\\n' + details.strip())).strip()\\n if draft is None:\\n msg = models.Message(issue_key=issue.key,\\n subject=subject,\\n sender=my_email,\\n recipients=reply_to,\\n text=text,\\n parent=issue.key,\\n issue_was_closed=issue.closed)\\n else:\\n msg = draft\\n msg.subject = subject\\n msg.recipients = reply_to\\n msg.text = text\\n msg.draft = False\\n msg.date = datetime.datetime.now()\\n msg.issue_was_closed = issue.closed\\n issue.calculate_updates_for(msg)\\n\\n if in_reply_to:\\n try:\\n replied_msg_id = int(in_reply_to)\\n replied_msg = models.Message.get_by_id(replied_msg_id, parent=issue.key)\\n msg.in_reply_to_key = replied_msg.key\\n replied_issue_id = replied_msg.issue_key.id()\\n if replied_issue_id != issue_id:\\n logging.warn('In-reply-to Message is for a different issue: '\\n '%s instead of %s', replied_issue_id, issue_id)\\n msg.in_reply_to_key = None\\n except (db.KindError, db.BadKeyError, ValueError):\\n logging.warn('Invalid in-reply-to Message or key given: %s', in_reply_to)\\n\\n if send_mail:\\n # Limit the list of files in the email to approximately 200\\n if 'files' in context and len(context['files']) > 210:\\n num_trimmed = len(context['files']) - 200\\n del context['files'][200:]\\n context['files'].append('[[ %d additional files ]]' % num_trimmed)\\n url = request.build_absolute_uri(reverse(show, args=[issue.key.id()]))\\n reviewer_nicknames = ', '.join(library.get_nickname(rev_temp, True,\\n request)\\n for rev_temp in issue.reviewers)\\n cc_nicknames = ', '.join(library.get_nickname(cc_temp, True, request)\\n for cc_temp in cc)\\n my_nickname = library.get_nickname(request.user, True, request)\\n reply_to = ', '.join(reply_to)\\n description = (issue.description or '').replace('\\\\r\\\\n', '\\\\n')\\n home = request.build_absolute_uri(reverse(index))\\n modified_added_count, modified_removed_count = _get_modified_counts(issue)\\n context.update({'reviewer_nicknames': reviewer_nicknames,\\n 'cc_nicknames': cc_nicknames,\\n 'my_nickname': my_nickname, 'url': url,\\n 'message': message, 'details': details,\\n 'description': description, 'home': home,\\n 'added_lines' : modified_added_count,\\n 'removed_lines': modified_removed_count,\\n })\\n for key, value in context.iteritems():\\n if isinstance(value, str):\\n try:\\n encoding.force_unicode(value)\\n except UnicodeDecodeError:\\n logging.error('Key %s is not valid unicode. value: %r' % (key, value))\\n # The content failed to be decoded as utf-8. Enforce it as ASCII.\\n context[key] = value.decode('ascii', 'replace')\\n body = django.template.loader.render_to_string(\\n template, context, context_instance=RequestContext(request))\\n logging.warn('Mail: to=%s; cc=%s', ', '.join(to), ', '.join(cc))\\n send_args = {'sender': my_email,\\n 'to': [_encode_safely(address) for address in to],\\n 'subject': _encode_safely(subject),\\n 'body': _encode_safely(body),\\n 'reply_to': _encode_safely(reply_to)}\\n if cc:\\n send_args['cc'] = [_encode_safely(address) for address in cc]\\n if patch:\\n send_args['attachments'] = [('issue_%s_patch.diff' % issue.key.id(),\\n patch)]\\n\\n attempts = 0\\n while True:\\n try:\\n mail.send_mail(**send_args)\\n break\\n except mail.InvalidSenderError:\\n if django_settings.RIETVELD_INCOMING_MAIL_ADDRESS:\\n previous_sender = send_args['sender']\\n if previous_sender not in send_args['to']:\\n send_args['to'].append(previous_sender)\\n send_args['sender'] = django_settings.RIETVELD_INCOMING_MAIL_ADDRESS\\n else:\\n raise\\n except apiproxy_errors.DeadlineExceededError:\\n # apiproxy_errors.DeadlineExceededError is raised when the\\n # deadline of an API call is reached (e.g. for mail it's\\n # something about 5 seconds). It's not the same as the lethal\\n # runtime.DeadlineExeededError.\\n attempts += 1\\n if attempts >= 3:\\n raise\\n if attempts:\\n logging.warning(\\\"Retried sending email %s times\\\", attempts)\\n\\n return msg\",\n \"def create_message(self, sender, to, subject, message_text):\\n message = MIMEText(message_text, 'html')\\n message['to'] = str(to)\\n message['from'] = str(sender)\\n message['subject'] = str(subject)\\n encoded_message = base64.urlsafe_b64encode(\\n message.as_string().encode('utf-8')).decode('ascii')\\n print(encoded_message, 'this is encoded_message')\\n return {'raw': encoded_message}\",\n \"def create_message(self, sender, to, subject, message_text):\\n message = MIMEText(message_text, 'html')\\n message['to'] = str(to)\\n message['from'] = str(sender)\\n message['subject'] = str(subject)\\n encoded_message = base64.urlsafe_b64encode(\\n message.as_string().encode('utf-8')).decode('ascii')\\n print(encoded_message, 'this is encoded_message')\\n return {'raw': encoded_message}\",\n \"def build_message():\\n outgoing_mail = Mail()\\n outgoing_mail.from_email = Email(email_from_address, email_from_name)\\n outgoing_mail.subject = subject\\n personalization = Personalization()\\n for recipient in email_to_addresses:\\n personalization.add_to(Email(recipient))\\n outgoing_mail.add_personalization(personalization)\\n outgoing_mail.add_content(Content(\\\"text/plain\\\", str.join('\\\\n', _log)))\\n outgoing_mail.add_content(Content(\\\"text/html\\\", \\\"<html><body> {} </body></html>\\\".format(str.join(' <br /> ', _log))))\\n return outgoing_mail.get()\",\n \"def test_notification_creation_email(self):\\n mailhost = api.portal.get_tool('MailHost')\\n self.assertEqual(len(mailhost.messages), 1)\\n msg = message_from_string(mailhost.messages[0])\\n\\n self.assertEqual(msg['To'], BOARD_LIST_ADDRESS)\\n self.assertEqual(\\n msg['From'], 'EESTEC International <noreply@eestec.net>')\\n self.assertEqual(\\n msg['Subject'],\\n '=?utf-8?q?=5BEVENTS=5D=5BCreated=5D_T=C3=A9st_event?=',\\n )\\n self.assertIn('a new Event has been created', msg.get_payload())\\n self.assertIn('T=C3=A9st event', msg.get_payload())\",\n \"def create_message(author, text):\\n\\n message = Message(author=author, text=text)\\n\\n db.session.add(message)\\n db.session.commit()\\n\\n return message\",\n \"def create_message(message_content, timestamp, username, channel, message_type):\\n return Message.objects.create(\\n message_content=message_content,\\n datetime_start=timestamp_to_datetime(timestamp),\\n username=username,\\n typing=True,\\n channel=channel,\\n message_type=message_type\\n )\",\n \"def create_message(sender, to, subject, message_text, image_directory=None):\\n message = MIMEMultipart()\\n message['to'] = to if isinstance(to, str) else ','.join(to)\\n if sender:\\n message['from'] = sender\\n message['subject'] = subject\\n\\n msg = MIMEText(message_text, 'html')\\n message.attach(msg)\\n\\n if image_directory:\\n for image_name in os.listdir(image_directory):\\n with open(os.path.join(image_directory, image_name), 'rb') as img_data:\\n content_type, encoding = mimetypes.guess_type(image_name)\\n\\n if content_type is None or encoding is not None:\\n content_type = 'application/octet-stream'\\n main_type, sub_type = content_type.split('/', 1)\\n if main_type == 'image':\\n msg = MIMEImage(img_data.read(), _subtype=sub_type)\\n else:\\n msg = MIMEBase(main_type, sub_type)\\n msg.set_payload(img_data.read())\\n\\n msg.add_header('Content-Id', '<' + image_name.split('.')[0] + '>') # angle brackets are important\\n message.attach(msg)\\n\\n # https://www.pronoy.in/2016/10/20/python-3-5-x-base64-encoding-3/\\n return {'raw': base64.urlsafe_b64encode(message.as_bytes()).decode('ascii')}\",\n \"def create_next_message(self, **kwargs):\\n message = self._builder.create_message(**kwargs)\\n return message\",\n \"def create_base_message(subject, msg=None):\\n message = EmailMessage()\\n message[\\\"From\\\"] = email_config.from_address\\n message[\\\"To\\\"] = email_config.to_addresses\\n message[\\\"Subject\\\"] = subject\\n message.set_content(\\\"\\\\n\\\".join([\\n 50 * \\\"_\\\",\\n f\\\"Hostname: {gethostname()}\\\",\\n f\\\"Time: {datetime.now().strftime(config.datetime_format)}\\\",\\n f\\\"Log file: {LOGGER.log_file_path}\\\",\\n 50 * \\\"_\\\",\\n ]))\\n # Add `msg` to the contents if it is not None\\n if msg is not None:\\n _append_content(message, msg)\\n # Attach the log file if it is available\\n if LOGGER.log_file_path is not None and config.email_attach_log_file:\\n _attach_log_file(message)\\n return message.as_string()\",\n \"def build_hello_email():\\n from_email = Email(\\\"test@example.com\\\")\\n subject = \\\"Hello World from the SendGrid Python Library\\\"\\n to_email = Email(\\\"test@example.com\\\")\\n content = Content(\\\"text/plain\\\", \\\"some text here\\\")\\n mail = Mail(from_email, subject, to_email, content)\\n mail.personalizations[0].add_to(Email(\\\"test2@example.com\\\"))\\n\\n return mail.get()\",\n \"def create_user_message(self, *args, **kwargs) -> UserMessage:\\n \\n raise NotImplementedError()\",\n \"def create(cls, course_id, sender, to_option, subject, html_message, text_message=None):\\r\\n # automatically generate the stripped version of the text from the HTML markup:\\r\\n if text_message is None:\\r\\n text_message = html_to_text(html_message)\\r\\n\\r\\n # perform some validation here:\\r\\n if to_option not in TO_OPTIONS:\\r\\n fmt = 'Course email being sent to unrecognized to_option: \\\"{to_option}\\\" for \\\"{course}\\\", subject \\\"{subject}\\\"'\\r\\n msg = fmt.format(to_option=to_option, course=course_id, subject=subject)\\r\\n raise ValueError(msg)\\r\\n\\r\\n # create the task, then save it immediately:\\r\\n course_email = cls(\\r\\n course_id=course_id,\\r\\n sender=sender,\\r\\n to_option=to_option,\\r\\n subject=subject,\\r\\n html_message=html_message,\\r\\n text_message=text_message,\\r\\n )\\r\\n course_email.save_now()\\r\\n\\r\\n return course_email\",\n \"def create_message(message_author, message_text):\\n\\n message = Message(message_author=message_author, message_text=message_text)\\n\\n db.session.add(message)\\n db.session.commit()\\n\\n return message\",\n \"def cmd_conversation_create(client, args):\\n create_message = client.create_message(args.recipient, args.body)\\n generate_output({'create_message': create_message})\",\n \"def _message(self, recipient, connection, context=None):\\n base_subject = '{{ event.calendar.course.name }} {{ event.title }}'\\n if not self.event.get_documents(True):\\n template_name = self.REQUEST_TEMPLATE\\n subject = 'Got a {} study guide?'.format(base_subject)\\n else:\\n template_name = self.PUBLISH_TEMPLATE\\n subject = '{} study guide'.format(base_subject)\\n\\n subject = Template(subject).render(context)\\n body = get_template(template_name).render(context)\\n\\n return make_email_message(subject, body,\\n make_display_email(\\n self.sender_address,\\n self.sender_name),\\n recipient, connection)\",\n \"def submit_message_from_message(message,body,by=None):\\n if not by:\\n by = Person.objects.get(name=\\\"(System)\\\")\\n msg = Message.objects.create(\\n by = by,\\n subject = message.get('subject',''),\\n frm = message.get('from',''),\\n to = message.get('to',''),\\n cc = message.get('cc',''),\\n bcc = message.get('bcc',''),\\n reply_to = message.get('reply_to',''),\\n body = body,\\n time = utc_from_string(message.get('date', ''))\\n )\\n return msg\",\n \"def new_email(self, context, payload):\\n\\n access_token = util.get_access_token(context['headers'])\\n url = util.get_url(context) + f\\\"messages/{payload['id']}\\\"\\n response = util.rest(\\\"GET\\\", url, access_token)\\n\\n if response.status_code > 400:\\n raise Exception(\\\"Error \\\", response.text)\\n\\n email_obj = json.loads(response.text)\\n\\n return GmailApi.get_email_data(email_obj)\",\n \"def message_new(self, cr, uid, msg, custom_values=None, context=None):\\n if custom_values is None: custom_values = {}\\n\\n desc = html2plaintext(msg.get('body')) if msg.get('body') else ''\\n custom_values.update({\\n 'name': msg.get('subject') or _(\\\"No Subject\\\"),\\n 'description': desc,\\n 'email_from': msg.get('from'),\\n 'email_cc': msg.get('cc'),\\n 'user_id': False,\\n })\\n if msg.get('priority') in dict(crm.AVAILABLE_PRIORITIES):\\n custom_values['priority'] = msg.get('priority')\\n return super(crm_lead, self).message_new(cr, uid, msg, custom_values=custom_values, context=context)\",\n \"def get_message(self, email):\\n\\n message = MIMEText(self.message, 'html')\\n\\n message['Subject'] = self.subject\\n message['From'] = self.from_\\n message['To'] = email\\n\\n return message\",\n \"def create_group_message(group_name,subject,message,status,createdby):\\n query=\\\"INSERT INTO groupmails(group_name,subject,message,status,createdby)VALUES('{}','{}','{}','{}','{}')\\\".format(\\n group_name,subject,message,status,createdby\\n )\\n cur.execute(query)\",\n \"def create_message(message):\\n return {\\n \\\"id\\\": message.id,\\n \\\"from\\\": message.sender,\\n \\\"preview\\\": create_preview(message),\\n \\\"subject\\\": message.subject,\\n \\\"date\\\": message.date_created,\\n }\",\n \"def compose(self, msg, recipient):\\n email = Email(msg, self, recipient)\\n self.mailman.send(email)\",\n \"def create_user_message(user, message):\\n user_message = UserMessage(user=user, message=message)\\n\\n db.session.add(user_message)\\n db.session.commit()\\n\\n return user_message\",\n \"def build_email(self, email_from, email_to, subject, body, email_cc=None, email_bcc=None, reply_to=False,\\n attachments=None, message_id=None, references=None, object_id=False, subtype='plain', headers=None,\\n body_alternative=None, subtype_alternative='plain'):\\n email_from = email_from or self._get_default_from_address()\\n assert email_from, \\\"You must either provide a sender address explicitly or configure \\\"\\\\\\n \\\"using the combintion of `mail.catchall.domain` and `mail.default.from` \\\"\\\\\\n \\\"ICPs, in the server configuration file or with the \\\"\\\\\\n \\\"--email-from startup parameter.\\\"\\n\\n # Note: we must force all strings to to 8-bit utf-8 when crafting message,\\n # or use encode_header() for headers, which does it automatically.\\n\\n headers = headers or {} # need valid dict later\\n email_cc = email_cc or []\\n email_bcc = email_bcc or []\\n body = body or u''\\n\\n email_body = ustr(body)\\n email_text_part = MIMEText(email_body, _subtype=subtype, _charset='utf-8')\\n msg = MIMEMultipart()\\n\\n if not message_id:\\n if object_id:\\n message_id = tools.generate_tracking_message_id(object_id)\\n else:\\n message_id = make_msgid()\\n msg['Message-Id'] = encode_header(message_id)\\n if references:\\n msg['references'] = encode_header(references)\\n msg['Subject'] = encode_header(subject)\\n msg['From'] = encode_rfc2822_address_header(email_from)\\n del msg['Reply-To']\\n if reply_to:\\n msg['Reply-To'] = encode_rfc2822_address_header(email_from) #self.smtp_user\\n else:\\n msg['Reply-To'] = msg['From']\\n msg['To'] = encode_rfc2822_address_header(COMMASPACE.join(email_to))\\n if email_cc:\\n msg['Cc'] = encode_rfc2822_address_header(COMMASPACE.join(email_cc))\\n if email_bcc:\\n msg['Bcc'] = encode_rfc2822_address_header(COMMASPACE.join(email_bcc))\\n msg['Date'] = formatdate()\\n # Custom headers may override normal headers or provide additional ones\\n for key, value in headers.items():\\n msg[pycompat.to_text(ustr(key))] = encode_header(value)\\n\\n if subtype == 'html' and not body_alternative:\\n # Always provide alternative text body ourselves if possible.\\n text = html2text.html2text(email_body)\\n alternative_part = MIMEMultipart(_subtype=\\\"alternative\\\")\\n alternative_part.attach(MIMEText(text, _charset='utf-8', _subtype='plain'))\\n alternative_part.attach(email_text_part)\\n msg.attach(alternative_part)\\n elif body_alternative:\\n # Include both alternatives, as specified, within a multipart/alternative part\\n alternative_part = MIMEMultipart(_subtype=\\\"alternative\\\")\\n body_alternative_ = ustr(body_alternative)\\n alternative_body_part = MIMEText(body_alternative_, _subtype=subtype_alternative, _charset='utf-8')\\n alternative_part.attach(alternative_body_part)\\n alternative_part.attach(email_text_part)\\n msg.attach(alternative_part)\\n else:\\n msg.attach(email_text_part)\\n\\n if attachments:\\n for (fname, fcontent, mime) in attachments:\\n filename_rfc2047 = encode_header_param(fname)\\n if mime and '/' in mime:\\n maintype, subtype = mime.split('/', 1)\\n part = MIMEBase(maintype, subtype)\\n else:\\n part = MIMEBase('application', \\\"octet-stream\\\")\\n\\n # The default RFC2231 encoding of Message.add_header() works in Thunderbird but not GMail\\n # so we fix it by using RFC2047 encoding for the filename instead.\\n part.set_param('name', filename_rfc2047)\\n part.add_header('Content-Disposition', 'attachment', filename=filename_rfc2047)\\n\\n part.set_payload(fcontent)\\n encoders.encode_base64(part)\\n msg.attach(part)\\n return msg\",\n \"def CreateMessageWithAttachment(sender, to, subject, message_text, file_dir,\\n filename):\\n message = MIMEMultipart()\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n\\n msg = MIMEText(message_text)\\n message.attach(msg)\\n\\n path = os.path.join(file_dir, filename)\\n content_type, encoding = mimetypes.guess_type(path)\\n\\n main_type, sub_type = content_type.split('/', 1)\\n fp = open(path, 'rb')\\n msg = MIMEBase(main_type, sub_type)\\n msg.set_payload(fp.read())\\n\\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\\n encoders.encode_base64(msg)\\n\\n fp.close()\\n\\n message.attach(msg)\\n\\n return {'raw': base64.urlsafe_b64encode(bytes(message.as_string(), encoding='utf-8')).decode()}\",\n \"def _construct_message(self):\\n self.message[\\\"text\\\"] = \\\"\\\"\\n if self.from_:\\n self.message[\\\"text\\\"] += \\\"From: \\\" + self.from_ + \\\"\\\\n\\\"\\n if self.subject:\\n self.message[\\\"text\\\"] += \\\"Subject: \\\" + self.subject + \\\"\\\\n\\\"\\n\\n self.message[\\\"text\\\"] += self.body\\n self._add_attachments()\",\n \"def generate_withno_attachement(sender, recipient, subject, body):\\n # Basic Email formatting\\n message = email.message.EmailMessage()\\n message[\\\"From\\\"] = sender\\n message[\\\"To\\\"] = recipient\\n message[\\\"Subject\\\"] = subject\\n message.set_content(body)\\n return message\",\n \"def send_created_email(self):\\n if settings.NOTIFY_NEW_REG:\\n to = settings.NOTIFY_NEW_REG\\n message = \\\"\\\"\\\"\\\\\\nGreetings,<br><br>\\n\\nA new vehicle registration has been submitted by %s.<br><br>\\n\\nGo here to view or edit the request: <br>\\n<a href=\\\"%s\\\">%s</a>\\n<br><br>\\nSincerely,<br><br>\\nThe Janelia Parking Permit Program\\n \\\"\\\"\\\" % (self.user_display_name(), self.get_edit_url(True), self.get_edit_url(True))\\n subject = 'A new parking permit request has been entered'\\n from_email = 'parkingpermit-donotreply@janelia.hhmi.org'\\n text_content = re.sub(r'<[^>]+>','',message)\\n html_content = message\\n msg = EmailMultiAlternatives(subject, text_content, from_email, to)\\n msg.attach_alternative(html_content, \\\"text/html\\\")\\n msg.send()\",\n \"def format_message(to_email, to_name):\\r\\n\\r\\n message = MIMEMultipart(\\\"alternative\\\")\\r\\n message[\\\"From\\\"] = my_email\\r\\n message[\\\"To\\\"] = to_email\\r\\n\\r\\n # This message is formatted in HTML since it's the only way to embed links\\r\\n with open('message.html', 'r') as f:\\r\\n message[\\\"Subject\\\"] = f.readline().split('Subject: ', 1)[-1]\\r\\n raw = f.read() % to_name\\r\\n content = MIMEText(raw, \\\"html\\\")\\r\\n message.attach(content)\\r\\n return message\",\n \"def action_create_mail_messages(self):\\n self.check_recipients()\\n self.check_message()\\n messages = self.env['mail.message']\\n for recipient in self.recipient_ids:\\n messages |= recipient._create_mail_message()\\n return messages\",\n \"def get_email_message(self, subject, body, sender, recipients, attachment=None): # pylint: disable=too-many-arguments\\n msg = {}\\n source = {}\\n data = {}\\n\\n data[\\\"body\\\"] = body\\n data[\\\"from\\\"] = sender\\n data[\\\"subject\\\"] = subject\\n data[\\\"type\\\"] = \\\"cla-email-event\\\"\\n if isinstance(recipients, str):\\n data[\\\"recipients\\\"] = [recipients]\\n else:\\n data[\\\"recipients\\\"] = recipients\\n # Added MailChip/Mandrill support by setting the template and adding\\n # email body to the parameters list under the BODY attribute\\n data[\\\"template_name\\\"] = \\\"EasyCLA System Email Template\\\"\\n data[\\\"parameters\\\"] = {\\n \\\"BODY\\\": body\\n }\\n\\n msg[\\\"data\\\"] = data\\n\\n source[\\\"client_id\\\"] = \\\"easycla-service\\\"\\n source[\\\"description\\\"] = \\\"EasyCLA Service\\\"\\n source[\\\"name\\\"] = \\\"EasyCLA Service\\\"\\n msg[\\\"source_id\\\"] = source\\n\\n msg[\\\"id\\\"] = str(uuid.uuid4())\\n msg[\\\"type\\\"] = \\\"cla-email-event\\\"\\n msg[\\\"version\\\"] = \\\"0.1.0\\\"\\n json_string = json.dumps(msg)\\n # cla.log.debug(f'Email JSON: {json_string}')\\n return json_string\",\n \"def rpc_campaign_message_new(self, campaign_id, email_id, target_email, company_name, first_name, last_name):\\n\\t\\tsession = db_manager.Session()\\n\\t\\tmessage = db_models.Message()\\n\\t\\tmessage.id = email_id\\n\\t\\tmessage.campaign_id = campaign_id\\n\\t\\tmessage.target_email = target_email\\n\\t\\tmessage.company_name = company_name\\n\\t\\tmessage.first_name = first_name\\n\\t\\tmessage.last_name = last_name\\n\\t\\tsession.add(message)\\n\\t\\tsession.commit()\\n\\t\\tsession.close()\\n\\t\\treturn\",\n \"def makeMessage( name, *structure ):\\n return X12Message( name, *structure )\",\n \"def create_user_message(user_id, message_id):\\n user_message = UserMessage(user_id=user_id, message_id=message_id)\\n\\n db.session.add(user_message)\\n db.session.commit()\\n\\n return user_message\",\n \"def emailMessage(subjectTitle, recipientEmail, bodyMessage, attachmentName = None, attachmentFilePath = None):\\n msg = Message(\\n subjectTitle,\\n sender = os.getenv(tag+'email',base_config['email']) \\n )\\n for email in recipientEmail: \\n msg.add_recipient(email)\\n\\n msg.body = bodyMessage\\n\\n if attachmentName is not None and attachmentFilePath is not None:\\n with app.open_resource(attachmentFilePath) as fp:\\n msg.attach(attachmentName, \\\"text/plain\\\", fp.read())\\n\\n mail.send(msg)\",\n \"def build_message(self, recipient_email):\\n\\t\\tmessage = self.queue_doc.message\\n\\t\\tif not message:\\n\\t\\t\\treturn \\\"\\\"\\n\\n\\t\\tmessage = message.replace(\\n\\t\\t\\tself.message_placeholder(\\\"tracker\\\"), self.get_tracker_str(recipient_email)\\n\\t\\t)\\n\\t\\tmessage = message.replace(\\n\\t\\t\\tself.message_placeholder(\\\"unsubscribe_url\\\"), self.get_unsubscribe_str(recipient_email)\\n\\t\\t)\\n\\t\\tmessage = message.replace(self.message_placeholder(\\\"cc\\\"), self.get_receivers_str())\\n\\t\\tmessage = message.replace(\\n\\t\\t\\tself.message_placeholder(\\\"recipient\\\"), self.get_recipient_str(recipient_email)\\n\\t\\t)\\n\\t\\tmessage = self.include_attachments(message)\\n\\t\\treturn message\",\n \"def create_chat_message(self, author, message):\\n\\n return ChatMessage.objects.create(conversation=self.conversation,\\n author=author,\\n message=message)\",\n \"def get_sample_message(self):\\n message = MailgunMessage(self.bob, self.alice, \\\"Test Subject\\\", body_text=\\\"this is a test\\\")\\n message.add_to(self.frank)\\n message.add_to(self.bob)\\n message.add_cc(self.frank)\\n message.add_cc(self.alice)\\n message.add_cc(self.bob)\\n message.add_bcc(self.bob)\\n message.add_bcc(self.alice)\\n message.add_bcc(self.frank)\\n return message\",\n \"def _create_message(self, data, channel):\\n if data['type'] != 'message':\\n logging.info(\\\"Skipping message of type `%s'.\\\", data['type'])\\n return\\n\\n logging.debug('Message data: %s', json.dumps(data))\\n\\n try:\\n user = self.q(o.User).\\\\\\n filter(o.User.slackid == data['user']).one()\\n except KeyError:\\n user = self.q(o.User).\\\\\\n filter(o.User.slackid == data['comment']['user']).one()\\n\\n if not data['text'].strip():\\n logging.info(\\\"Skipping message from `%s' since it's empty\\\",\\n user.name)\\n return\\n\\n message = o.Message(data)\\n message.channel = channel\\n message.user = user\\n\\n if data.get('is_starred'):\\n message.is_starred = True\\n\\n if 'reactions' in data:\\n for reaction_data in data['reactions']:\\n message.reactions.append(o.Reaction(reaction_data))\\n\\n if data.get('subtype') == 'file_share':\\n self._file_data(message, data['file'], data['file']['is_external'])\\n elif data.get('subtype') == 'pinned_item':\\n if data.get('attachments'):\\n self._att_data(message, data['attachments'])\\n elif data.get('item'):\\n self._file_data(message, data['item'],\\n data['item']['is_external'])\\n elif data.get('attachments'):\\n self._att_data(message, data['attachments'])\\n\\n self.session.add(message)\",\n \"def prepare_message(self, body, priority=None, content_type=None,\\n content_encoding=None, headers=None, properties=None):\\n return amqp.Message(body, priority=priority,\\n content_type=content_type,\\n content_encoding=content_encoding,\\n application_headers=headers,\\n **properties)\",\n \"def CreateMessageWithAttachment(\\n sender, to, subject, message_text, file_dir, filename):\\n message = MIMEMultipart()\\n message['to'] = to\\n message['from'] = sender\\n message['subject'] = subject\\n\\n msg = MIMEText(message_text)\\n message.attach(msg)\\n\\n path = os.path.join(file_dir, filename)\\n content_type, encoding = mimetypes.guess_type(path)\\n\\n if content_type is None or encoding is not None:\\n content_type = 'application/octet-stream'\\n main_type, sub_type = content_type.split('/', 1)\\n if main_type == 'text':\\n fp = open(path, 'rb')\\n msg = MIMEText(fp.read(), _subtype=sub_type)\\n fp.close()\\n elif main_type == 'image':\\n fp = open(path, 'rb')\\n msg = MIMEImage(fp.read(), _subtype=sub_type)\\n fp.close()\\n elif main_type == 'audio':\\n fp = open(path, 'rb')\\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\\n fp.close()\\n else:\\n fp = open(path, 'rb')\\n msg = MIMEBase(main_type, sub_type)\\n msg.set_payload(fp.read())\\n fp.close()\\n\\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\\n message.attach(msg)\\n\\n return {'raw': base64.urlsafe_b64encode(message.as_string())}\",\n \"def create_message(self, ticket_number, author, body, note=True):\\n data = {\\n 'author': author,\\n 'body': body,\\n 'note': note\\n }\\n url = ('https://api.groovehq.com/v1/tickets/{}/messages'\\n .format(ticket_number))\\n resp = self._session.post(url, json=data)\\n\\n result = resp.json()\\n new_url = ret['message']['href']\\n nums = re.findall(r'\\\\d+', new_url)\\n\\n if len(nums) > 0:\\n return nums[-1]\",\n \"def construct_message(self):\\n msg_type = self.msg_type\\n if msg_type == \\\"PUBMSG\\\":\\n msg_type = \\\"PRIVMSG\\\"\\n ret = \\\"{} {}\\\".format(msg_type, self.target)\\n if self.content:\\n ret += \\\" :{}\\\".format(self.content)\\n return ret + \\\"\\\\r\\\\n\\\"\",\n \"def new_message(self, body=''):\\r\\n m = self.message_class(self, body)\\r\\n m.queue = self\\r\\n return m\",\n \"def draft_message(self, text=None, template_path=None, template_args=None):\\n self.message['From'] = self.sender\\n self.message['To'] = '; '.join(self.destinations)\\n self.message['BCC'] = '; '.join(self.bcc)\\n self.message['CC'] = '; '.join(self.cc)\\n self.message['Subject'] = self.subject\\n\\n # check if email template is used\\n if template_path:\\n text = self.body_template(template_path)\\n text = text.format(**template_args)\\n\\n # attach text part of message\\n self.message.attach(MIMEText(text))\\n\\n # return self to encourage method chaining\\n return self\",\n \"def send(self):\\n # Validate message\\n if self._text_body is None and self._html_body is None:\\n raise Exception(\\\"Error! Must specify at least one body type (HTML or Text)\\\")\\n if len(self._to) == 0:\\n raise Exception(\\\"Must specify at least one recipient\\\")\\n\\n # Create the message part\\n if self._text_body is not None and self._html_body is None:\\n msg = MIMEText(self._text_body, \\\"plain\\\")\\n elif self._text_body is None and self._html_body is not None:\\n msg = MIMEText(self._html_body, \\\"html\\\")\\n else:\\n msg = MIMEMultipart(\\\"alternative\\\")\\n msg.attach(MIMEText(self._text_body, \\\"plain\\\"))\\n msg.attach(MIMEText(self._html_body, \\\"html\\\"))\\n # Add attachments, if any\\n if len(self._attach) != 0:\\n tmpmsg = msg\\n msg = MIMEMultipart()\\n msg.attach(tmpmsg)\\n for fname,attachname in self._attach:\\n if not os.path.exists(fname):\\n print \\\"File '%s' does not exist. Not attaching to email.\\\" % fname\\n continue\\n if not os.path.isfile(fname):\\n print \\\"Attachment '%s' is not a file. Not attaching to email.\\\" % fname\\n continue\\n # Guess at encoding type\\n ctype, encoding = mimetypes.guess_type(fname)\\n if ctype is None or encoding is not None:\\n # No guess could be made so use a binary type.\\n ctype = 'application/octet-stream'\\n maintype, subtype = ctype.split('/', 1)\\n if maintype == 'text':\\n fp = open(fname)\\n attach = MIMEText(fp.read(), _subtype=subtype)\\n fp.close()\\n elif maintype == 'image':\\n fp = open(fname, 'rb')\\n attach = MIMEImage(fp.read(), _subtype=subtype)\\n fp.close()\\n elif maintype == 'audio':\\n fp = open(fname, 'rb')\\n attach = MIMEAudio(fp.read(), _subtype=subtype)\\n fp.close()\\n else:\\n fp = open(fname, 'rb')\\n attach = MIMEBase(maintype, subtype)\\n attach.set_payload(fp.read())\\n fp.close()\\n # Encode the payload using Base64\\n encoders.encode_base64(attach)\\n # Set the filename parameter\\n if attachname is None:\\n filename = os.path.basename(fname)\\n else:\\n filename = attachname\\n attach.add_header('Content-Disposition', 'attachment', filename=filename)\\n msg.attach(attach)\\n # Some header stuff\\n msg['Subject'] = self._subject\\n msg['From'] = self._from\\n msg['To'] = \\\", \\\".join(self._to)\\n if self._reply_to:\\n msg['Reply-To'] = self._reply_to\\n if len(self._cc) > 0:\\n msg['Cc'] = \\\", \\\".join(self._cc)\\n if len(self._bcc) > 0:\\n msg['Bcc'] = \\\", \\\".join(self._bcc)\\n msg.preamble = \\\"You need a MIME enabled mail reader to see this message\\\"\\n # Send message\\n msg = msg.as_string()\\n server = None\\n if self._smtp_ssl:\\n server = smtplib.SMTP_SSL(host=self._smtp_server,\\n port=self._smtp_port)\\n else:\\n server = smtplib.SMTP(host=self._smtp_server, port=self._smtp_port)\\n if self._smtp_user:\\n server.login(self._smtp_user, self._smtp_password)\\n server.sendmail(self._from, self._to, msg)\\n server.quit()\",\n \"def _create_message(self, msg):\\n head = msg[\\\"head\\\"]\\n body = msg[\\\"body\\\"]\\n body = body.format(**self.data)\\n length = len(body)\\n head = head.format(length=length, **self.data)\\n return head + body\",\n \"def create_email(username, provider):\\n print(f\\\"Your new email is {username}@{provider}.com\\\")\",\n \"def create_multipart_message(\\n sender: str, recipients: list, title: str, text: str = None, html_text: str = None, attachments: list = None) \\\\\\n -> MIMEMultipart:\\n multipart_content_subtype = 'alternative' if text and html_text else 'mixed'\\n msg = MIMEMultipart(multipart_content_subtype)\\n msg['Subject'] = title\\n msg['From'] = sender\\n msg['To'] = ', '.join(recipients)\\n\\n # Record the MIME types of both parts - text/plain and text/html.\\n # According to RFC 2046, the last part of a multipart message, in this case the HTML message, is best and preferred.\\n if text:\\n part = MIMEText(text, 'plain')\\n msg.attach(part)\\n if html_text:\\n part = MIMEText(html_text, 'html')\\n msg.attach(part)\\n\\n # Add attachments\\n for attachment in attachments or []:\\n with open(attachment, 'rb') as f:\\n part = MIMEApplication(f.read())\\n part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(attachment))\\n msg.attach(part)\\n\\n return msg\",\n \"def send_email(self, message):\\n pass\",\n \"def createMessageWithAttachment(\\r\\n sender, to, subject, msgHtml, msgPlain, attachmentFile):\\r\\n message = MIMEMultipart('mixed')\\r\\n message['to'] = to\\r\\n message['from'] = sender\\r\\n message['subject'] = subject\\r\\n\\r\\n messageA = MIMEMultipart('alternative')\\r\\n messageR = MIMEMultipart('related')\\r\\n\\r\\n messageR.attach(MIMEText(msgHtml, 'html'))\\r\\n messageA.attach(MIMEText(msgPlain, 'plain'))\\r\\n messageA.attach(messageR)\\r\\n\\r\\n message.attach(messageA)\\r\\n\\r\\n print(\\\"create_message_with_attachment: file: %s\\\" % attachmentFile)\\r\\n content_type, encoding = mimetypes.guess_type(attachmentFile)\\r\\n\\r\\n if content_type is None or encoding is not None:\\r\\n content_type = 'application/octet-stream'\\r\\n main_type, sub_type = content_type.split('/', 1)\\r\\n if main_type == 'text':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEText(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n elif main_type == 'image':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEImage(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n elif main_type == 'audio':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n else:\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEBase(main_type, sub_type)\\r\\n msg.set_payload(fp.read())\\r\\n fp.close()\\r\\n filename = os.path.basename(attachmentFile)\\r\\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\\r\\n message.attach(msg)\\r\\n\\r\\n return {'raw': base64.urlsafe_b64encode((message.as_string()).encode('UTF-8')).decode('ascii')}\",\n \"def createMessageWithAttachment(sender, to, subject, msgHtml, msgPlain, attachmentFile):\\r\\n message = MIMEMultipart('mixed')\\r\\n message['to'] = to\\r\\n message['from'] = sender\\r\\n message['subject'] = subject\\r\\n\\r\\n messageA = MIMEMultipart('alternative')\\r\\n messageR = MIMEMultipart('related')\\r\\n\\r\\n messageR.attach(MIMEText(msgHtml, 'html'))\\r\\n messageA.attach(MIMEText(msgPlain, 'plain'))\\r\\n messageA.attach(messageR)\\r\\n\\r\\n message.attach(messageA)\\r\\n\\r\\n print(\\\"create_message_with_attachment: file: %s\\\" % attachmentFile)\\r\\n content_type, encoding = mimetypes.guess_type(attachmentFile)\\r\\n\\r\\n if content_type is None or encoding is not None:\\r\\n content_type = 'application/octet-stream'\\r\\n main_type, sub_type = content_type.split('/', 1)\\r\\n if main_type == 'text':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEText(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n elif main_type == 'image':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEImage(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n elif main_type == 'audio':\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEAudio(fp.read(), _subtype=sub_type)\\r\\n fp.close()\\r\\n else:\\r\\n fp = open(attachmentFile, 'rb')\\r\\n msg = MIMEBase(main_type, sub_type)\\r\\n msg.set_payload(fp.read())\\r\\n fp.close()\\r\\n filename = os.path.basename(attachmentFile)\\r\\n msg.add_header('Content-Disposition', 'attachment', filename=filename)\\r\\n message.attach(msg)\\r\\n\\r\\n return {'raw': base64.urlsafe_b64encode(message.as_string())}\",\n \"def replyMessage(_email, _name):\\n\\n _mailer = app.config['MAIL_USERNAME']\\n mesg = Message(\\\"Message Received\\\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[_email])\\n mesg.body = f'''Hello {_name},\\nThe message you sent to Randy has been received. \\nRandy will contact you within 24 hours.\\nThank you.\\n\\nRegards,\\nRandy\\n\\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\\n'''\\n mail.send(mesg)\\n return 'OK'\",\n \"def create_message(self,message_information):\\n\\n #create the message\\n if message_information['service'] == 'whatsapp':\\n #The details of the message sent is saved here\\n message = self.client.messages.create(\\n body='Your order of {food} from the {store_name} store is ready. Additional Information: {addit_info}'.format(**message_information),\\n from_='whatsapp:{sender_number}'.format(**self.config),\\n to='whatsapp:{mobile}'.format(**message_information)\\n )\\n #Set the ready state to waiting for collection\\n #self.firebase.db.child('orders').child('{store_name}'.format(**message_information)).child('{order_id}'.format(**message_information)).update({\\\"ready\\\":\\\"waiting for collection\\\"})\\n self.firebase.update([\\\"orders\\\", STORE_NAME, message_information[\\\"order_id\\\"]], {\\\"ready\\\": \\\"waiting for collection\\\"})\",\n \"def _copy_message(self, message):\\r\\n gmsg = aeemail.EmailMessage(sender=message.from_email,\\r\\n to=message.to,\\r\\n subject=message.subject,\\r\\n body=message.body)\\r\\n if message.extra_headers.get('Reply-To', None):\\r\\n gmsg.reply_to = message.extra_headers['Reply-To']\\r\\n if message.cc:\\r\\n gmsg.cc = list(message.cc)\\r\\n if message.bcc:\\r\\n gmsg.bcc = list(message.bcc)\\r\\n if message.attachments:\\r\\n # Must be populated with (filename, filecontents) tuples.\\r\\n attachments = []\\r\\n for attachment in message.attachments:\\r\\n if isinstance(attachment, MIMEBase):\\r\\n attachments.append((attachment.get_filename(),\\r\\n attachment.get_payload(decode=True)))\\r\\n else:\\r\\n attachments.append((attachment[0], attachment[1]))\\r\\n gmsg.attachments = attachments\\r\\n # Look for HTML alternative content.\\r\\n if isinstance(message, EmailMultiAlternatives):\\r\\n for content, mimetype in message.alternatives:\\r\\n if mimetype == 'text/html':\\r\\n gmsg.html = content\\r\\n break\\r\\n return gmsg\",\n \"def create_email(_from, _to, _subj, _body, files):\\r\\n msg = MIMEMultipart()\\r\\n msg['From'] = _from\\r\\n msg['To'] = _to\\r\\n msg['Subject'] = _subj\\r\\n msg.attach(MIMEText(_body, 'plain'))\\r\\n\\r\\n if files:\\r\\n for file in files:\\r\\n part = MIMEBase('application', 'octet-stream')\\r\\n part.set_payload(open(file, 'rb').read())\\r\\n encoders.encode_base64(part)\\r\\n part.add_header('Content-Disposition', 'attachment; filename=' + os.path.basename(file))\\r\\n msg.attach(part)\\r\\n\\r\\n return msg\",\n \"def sendEmail(_name, _email, _body):\\n\\n _mailer = app.config['MAIL_USERNAME']\\n msg = Message(\\\"Contact Form\\\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\\n msg.body = f'''{_body}\\n\\n\\nSender's Name: {_name}\\nSender's Email: {_email}\\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\\n'''\\n mail.send(msg)\\n return 'OK'\",\n \"def make_email(to_list=None, cc_list=None, bcc_list=None, from_address=None, reply_address=None, attachments=None,\\n subject=None, body=None, template=None, html=False):\\n if template is not None and (subject is not None or body is not None):\\n raise ValueError('Only subject/body or template can be passed')\\n\\n if template:\\n subject = template.get_subject()\\n body = template.get_body()\\n if config.DEBUG and '\\\\n' in subject:\\n raise ValueError('Email subject contains linebreaks')\\n subject = re.sub(r'\\\\s+', ' ', subject)\\n if to_list is None:\\n to_list = set()\\n if cc_list is None:\\n cc_list = set()\\n if bcc_list is None:\\n bcc_list = set()\\n to_list = {to_list} if isinstance(to_list, str) else to_list\\n cc_list = {cc_list} if isinstance(cc_list, str) else cc_list\\n bcc_list = {bcc_list} if isinstance(bcc_list, str) else bcc_list\\n reply_address = {reply_address} if (isinstance(reply_address, str) and reply_address) else (reply_address or set())\\n return {\\n 'to': set(to_list),\\n 'cc': set(cc_list),\\n 'bcc': set(bcc_list),\\n 'from': from_address or config.NO_REPLY_EMAIL,\\n 'reply_to': set(reply_address),\\n 'attachments': attachments or [],\\n 'subject': subject.strip(),\\n 'body': body.strip(),\\n 'html': html,\\n }\",\n \"def create_sent_email(self, *args, **kwargs):\\n receiver = kwargs['receiver']\\n sender = kwargs['sender']\\n user = kwargs['user']\\n body = kwargs['body']\\n subject = kwargs['subject']\\n if receiver and sender and subject and body:\\n sent_email = SentEmail()\\n sent_email.receiver = receiver\\n sent_email.subject = subject\\n sent_email.sender = sender\\n sent_email.status = 'sent'\\n sent_email.user = user\\n sent_email.body = body\\n sent_email.save()\\n return True\\n else:\\n return False\",\n \"def create(\\n cls,\\n recipient_id: str,\\n recipient_email: str,\\n sender_id: str,\\n sender_email: str,\\n intent: str,\\n subject: str,\\n html_body: str,\\n sent_datetime: datetime.datetime\\n ) -> None:\\n instance_id = cls._generate_id(intent)\\n email_model_instance = cls(\\n id=instance_id, recipient_id=recipient_id,\\n recipient_email=recipient_email, sender_id=sender_id,\\n sender_email=sender_email, intent=intent, subject=subject,\\n html_body=html_body, sent_datetime=sent_datetime)\\n\\n email_model_instance.update_timestamps()\\n email_model_instance.put()\",\n \"def make_and_mail(receiver, subject, body):\\n emailbody = MIMEText(body, 'html')\\n msg = MIMEMultipart('alternative')\\n msg['From'] = SENDER\\n msg['To'] = receiver\\n msg['Subject'] = subject\\n msg.attach(emailbody)\\n #pylint: disable=invalid-name\\n try:\\n s = smtplib.SMTP('smtp.gmail.com', 587)\\n s.starttls()\\n s.login(YOUPAPER_EMAIL, YOUPAPER_PASSWORD)\\n s.sendmail(SENDER, receiver, msg.as_string())\\n s.quit()\\n return 1 #returns 1 if success\\n except smtplib.SMTPException:\\n return 0 #returns 0 if failure\",\n \"def post(self, request):\\n # get message from request\\n message = request.POST.get('message')\\n # create message\\n\\n ChatMessage.objects.create(\\n message=message, _from=request.user, _to=request.user.client.trainer.user)\\n # return response\\n return HttpResponse('success')\",\n \"def send_feedback_message_email(recipient_id, feedback_messages):\\n email_subject_template = (\\n 'You\\\\'ve received %s new message%s on your explorations')\\n\\n email_body_template = (\\n 'Hi %s,<br>'\\n '<br>'\\n 'You\\\\'ve received %s new message%s on your Oppia explorations:<br>'\\n '<ul>%s</ul>'\\n 'You can view and reply to your messages from your '\\n '<a href=\\\"https://www.oppia.org/creator_dashboard\\\">dashboard</a>.'\\n '<br>'\\n '<br>Thanks, and happy teaching!<br>'\\n '<br>'\\n 'Best wishes,<br>'\\n 'The Oppia Team<br>'\\n '<br>%s')\\n\\n if not feconf.CAN_SEND_EMAILS:\\n log_new_error('This app cannot send emails to users.')\\n return\\n\\n if not feconf.CAN_SEND_FEEDBACK_MESSAGE_EMAILS:\\n log_new_error('This app cannot send feedback message emails to users.')\\n return\\n\\n if not feedback_messages:\\n return\\n\\n recipient_user_settings = user_services.get_user_settings(recipient_id)\\n\\n messages_html = ''\\n count_messages = 0\\n for exp_id, reference in feedback_messages.iteritems():\\n messages_html += (\\n '<li><a href=\\\"https://www.oppia.org/create/%s#/feedback\\\">'\\n '%s</a>:<br><ul>' % (exp_id, reference['title']))\\n for message in reference['messages']:\\n messages_html += ('<li>%s<br></li>' % message)\\n count_messages += 1\\n messages_html += '</ul></li>'\\n\\n email_subject = email_subject_template % (\\n (count_messages, 's') if count_messages > 1 else ('a', ''))\\n\\n email_body = email_body_template % (\\n recipient_user_settings.username, count_messages if count_messages > 1\\n else 'a', 's' if count_messages > 1 else '', messages_html,\\n EMAIL_FOOTER.value)\\n\\n _send_email(\\n recipient_id, feconf.SYSTEM_COMMITTER_ID,\\n feconf.EMAIL_INTENT_FEEDBACK_MESSAGE_NOTIFICATION,\\n email_subject, email_body, feconf.NOREPLY_EMAIL_ADDRESS)\",\n \"def send_email(to, subject, body, attachment=None):\\n outlook = win32.Dispatch('outlook.application')\\n new_mail = outlook.CreateItem(0)\\n new_mail.Subject = subject\\n new_mail.HTMLBody = body\\n new_mail.To = to\\n\\n if attachment:\\n new_mail.Attachments.Add(attachment)\\n\\n new_mail.Send()\",\n \"def create_and_deliver(self, **kwargs: Any) -> Awaitable[None]:\\n\\n msg = self.create_message(**kwargs)\\n return self.deliver(msg)\",\n \"def new_message(self,\\n intent=\\\"\\\",\\n message=\\\"\\\",\\n type=None,\\n not_handled=False,\\n time_stamp=None):\\n self.messages.append(Message(api_key=self.api_key,\\n platform=self.platform,\\n version=self.version,\\n user_id=self.user_id,\\n intent=intent,\\n message=message,\\n type=type,\\n not_handled=not_handled,\\n time_stamp=time_stamp))\\n return self.messages[-1]\",\n \"def _create_msg(self, tr_id, payload, confirm, expire_time, encoding):\\n tmp = [\\\"<SSAP_message><transaction_type>INSERT</transaction_type>\\\",\\n \\\"<message_type>REQUEST</message_type>\\\"]\\n tmp.extend([\\\"<transaction_id>\\\", str(tr_id), \\\"</transaction_id>\\\"])\\n tmp.extend([\\\"<node_id>\\\", str(self.node_id), \\\"</node_id>\\\"])\\n tmp.extend([\\\"<space_id>\\\", str(self.targetSS), \\\"</space_id>\\\"])\\n tmp.extend(['<parameter name=\\\"insert_graph\\\" encoding=\\\"%s\\\">' % encoding.upper(),\\n str(payload), \\\"</parameter>\\\"])\\n tmp.extend(['<parameter name = \\\"confirm\\\">',\\n str(confirm).upper(),\\n \\\"</parameter>\\\",\\n \\\"</SSAP_message>\\\"])\\n return \\\"\\\".join(tmp)\",\n \"def test_post_success_creates_message(self):\\n sender, recipient = UserFactory(), UserFactory()\\n\\n data = {\\n 'senderId': sender.id,\\n 'recipientId': recipient.id,\\n 'text': 'Hello World!',\\n }\\n\\n response = self.client.post(\\n reverse('messages:list'),\\n content_type='application/json',\\n data=data,\\n )\\n actual_message = Message.objects.get()\\n self.assertEqual(sender.id, actual_message.sender.id)\\n self.assertEqual(recipient.id, actual_message.recipient.id)\\n self.assertEqual(data['text'], actual_message.text)\",\n \"def send_msg(self, body, who, subject=None, **kwargs):\\n\\n # ============================================================\\n # Parse and bail out if needed\\n # ============================================================\\n\\n self._parse_who(who)\\n\\n if not self._ensure_recipients_exist():\\n return\\n\\n # Kwargs\\n attachment = kwargs.get('attachment', None)\\n disable_email = kwargs.get('disable_email', False)\\n disable_sms = kwargs.get('disable_sms', False)\\n\\n if not self._ensure_attachment_exists(attachment):\\n return\\n\\n for b, n in zip([disable_email, disable_sms], ['disable_email', 'disable_sms']):\\n if not isinstance(b, bool):\\n msg = f'\\\\'{n}\\\\' must be boolean but you gave type {type(b)}'\\n raise TypeError(msg)\\n\\n # ============================================================\\n # Main\\n # ============================================================\\n\\n with self._setup_smtp_server() as sess:\\n\\n # Create msg object\\n msg = EmailMessage()\\n\\n # Personalize the template\\n body_from_template = self.template.substitute(BODY=body)\\n\\n # Set msg parameters;\\n # Note we will assign msg['To'] below when iterating over email addresses\\n msg['From'] = self.sender_address\\n msg['Subject'] = subject.upper() if isinstance(subject, str) else None\\n\\n # Copy outgoing emails to cc list\\n if isinstance(self.cc_email_list, list):\\n if len(self.cc_email_list) > 0:\\n msg['CC'] = ','.join(self.cc_email_list)\\n\\n # Base text message\\n msg.set_content(body_from_template)\\n\\n # HTML version\\n body_html = re.sub(r'[\\\\n]', '<br>', body_from_template) # Replace /n with <br>\\n logo_cid = make_msgid()\\n msg.add_alternative(\\\"\\\"\\\"\\\\\\n <html>\\n <head></head>\\n <body>\\n <p>\\\"\\\"\\\" + body_html + '</p>' + \\\"\\\"\\\"\\n <a href=\\\"https://www.liveline.tech\\\">\\n <img src=\\\"cid:{logo_cid}\\\" />\\n </a>\\n </body>\\n </html>\\n \\\"\\\"\\\".format(logo_cid=logo_cid[1:-1]), subtype='html')\\n\\n # Add logo to the HTML version\\n if EMAIL_SIGNATURE_LOGO_FILE is not None:\\n t = root / EMAIL_SIGNATURE_LOGO_FILE\\n if t.exists():\\n with open(t, 'rb') as img:\\n r = img.read()\\n # noinspection PyUnresolvedReferences\\n msg.get_payload()[1].add_related(r, 'image', 'png', cid=logo_cid)\\n\\n # Optionally attach a file\\n # First use mimetypes to try and guess content type based on file extension:\\n if attachment is not None:\\n attachment = Path(attachment)\\n ctype, encoding = mimetypes.guess_type(str(attachment))\\n if ctype is None or encoding is not None:\\n # No guess could be made, or the file is encoded (compressed), so\\n # use a generic bag-of-bits type.\\n ctype = 'application/octet-stream'\\n maintype, subtype = ctype.split('/', 1)\\n maintype += f'; name=\\\"{attachment.name}\\\"'\\n with open(attachment, 'rb') as file:\\n r = file.read()\\n msg.add_attachment(r, maintype=maintype, subtype=subtype)\\n\\n # ============================================================\\n # Email\\n # ============================================================\\n\\n # For each email & phone in current lists, send messages\\n if not disable_email:\\n for e in self.current_email_list:\\n\\n # Console out\\n stdout_msg = f'COMMUNICATOR MESSAGE: Sending email to: '\\n fancy_print(stdout_msg, fg=COMMUNICATOR_MSG_COLOR, end='')\\n fancy_print(e, fg='hlink')\\n\\n # Update msg 'To:' field\\n if msg['To'] is not None:\\n del msg['To']\\n msg['To'] = e\\n\\n # # Make a local copy of what we are going to send... to a log file?\\n # with open('outgoing.msg', 'wb') as f:\\n # f.write(bytes(msg))\\n\\n try:\\n sess.send_message(msg)\\n except:\\n stdout_msg = f'COMMUNICATOR WARNING: Failed sending email message'\\n fancy_print(stdout_msg, fg=COMMUNICATOR_WARN_COLOR)\\n\\n # ============================================================\\n # SMS\\n # ============================================================\\n\\n if not disable_sms:\\n for m in self.current_mobile_list:\\n\\n # Console out\\n stdout_msg = f'COMMUNICATOR MESSAGE: Sending SMS message to: '\\n fancy_print(stdout_msg, fg=COMMUNICATOR_MSG_COLOR, end='')\\n fancy_print(m[0:3] + '.' + m[3:6] + '.' + m[6:10], fg='cerulean')\\n\\n any_ok = False\\n candidates = list()\\n\\n # Try all the stubs!\\n # We don't know the carrier name.\\n # Assume the invalid addresses will get black-holed by the various carriers.\\n for stub in self.sms_email_stubs:\\n candidates.append(m + self.sms_email_stubs[stub])\\n\\n # Update msg 'To:' field\\n if msg['To'] is not None:\\n del msg['To']\\n msg['To'] = candidates\\n\\n # # Make a local copy of what we are going to send... to a log file?\\n # with open('outgoing.msg', 'wb') as f:\\n # f.write(bytes(msg))\\n\\n try:\\n sess.send_message(msg)\\n any_ok = True\\n except:\\n pass\\n\\n if not any_ok:\\n stdout_msg = f'COMMUNICATOR WARNING: Failed sending SMS message'\\n fancy_print(stdout_msg, fg=COMMUNICATOR_WARN_COLOR)\\n\\n return\",\n \"def create_email(user):\\n if 'research' in user.get_domains():\\n domain = 'research'\\n else: domain = 'academic'\\n subject = \\\"ECE/CIS Account Created\\\"\\n helprequest = \\\"https://www.eecis.udel.edu/service\\\"\\n \\n message = \\\"Your ECE/CIS %s account has been created with the username: %s\\\\n\\\\n\\\" % (domain, user.username)\\n message += \\\"Please do not reply to this message. If you need assistance with your account, please visit:\\\\n\\\"\\n message += \\\"%s\\\\n\\\\n\\\" % helprequest\\n message += \\\"-- EE/CIS Labstaff\\\\n\\\"\\n\\n send('account@eecis.udel.edu', 'ECE/CIS Account System', \\\\\\n [user.email], subject, message, MAILHOST)\",\n \"def build_message(self, subject, body, attachment=None):\\n msg = MIMEMultipart()\\n msg['From'] = self.src_addr\\n msg['To'] = self.dest_addr\\n msg['Subject'] = subject\\n msg.attach(MIMEText(body, 'plain'))\\n\\n if attachment is not None:\\n if os.path.exists(attachment):\\n with open(attachment, 'rb') as a:\\n part = MIMEBase('application', 'octet-stream')\\n part.set_payload(a.read())\\n encoders.encode_base64(part)\\n part.add_header('Content-Disposition', 'attachment; filename= {}'.format(attachment))\\n msg.attach(part)\\n\\n self.outbox.append(msg)\",\n \"def br_msg_to(msg_body):\\r\\n msg = Message()\\r\\n msg.body = msg_body\\r\\n msg.set_metadata(\\\"performative\\\", \\\"inform\\\")\\r\\n return msg\",\n \"def message_new(\\n self, cr, uid, msg_dict, custom_values=None, context=None): \\n if context is None:\\n context = {}\\n # prevent changes in context from \\\"bubbling up\\\" to calling methods\\n local_context = dict(context)\\n\\n users_pool = self.pool.get('res.users')\\n base_model = self.pool.get('ir.model.data')\\n partner_model = self.pool.get('res.partner') \\n\\n # As the scheduler is run without language,\\n # set the administrator's language\\n if not local_context.get('lang'):\\n user = users_pool.browse(cr, uid, uid, context=local_context)\\n local_context['lang'] = user.partner_id.lang\\n\\n if custom_values is None:\\n custom_values = {}\\n email_from = msg_dict.get('from', False)\\n if email_from:\\n custom_values['name'] = _(\\\"Received by email from %s\\\") % email_from\\n email_date = msg_dict.get('date', False)\\n if email_date:\\n custom_values['date_invoice'] = email_date\\n\\n company_id = (\\n ('force_company' in local_context\\n and local_context['force_company']) or False)\\n\\n # Retrieve partner_id from message dictionary.\\n # Partner might be:\\n # 1. Supplier sending email (author_id in msg dict.)\\n # 2. Partner receiving message (special partner setup to receive\\n # email). Should be linked to the appropiate company in multi-\\n # company databases.\\n # 3. Dummy invoice partner.\\n # Partner MUST be a supplier.\\n\\n # 1. Try author:\\n supplier_partner_id = False\\n author_id = (\\n 'author_id' in msg_dict and msg_dict['author_id'] or False)\\n if (author_id\\n and self._is_partner_supplier(\\n cr, uid, author_id, context=local_context)):\\n supplier_partner_id = author_id\\n\\n # 2. Try recipients:\\n # Unfortunately we have to do a new lookup on partner, because\\n # the method message_process in mail_thread removes the partner_ids\\n # already found, from the message dictionary:\\n if not supplier_partner_id:\\n s = ', '.join(\\n [msg_dict.get(h)\\n for h in ['to', 'cc'] if msg_dict.get(h)])\\n for email_address in tools.email_split(s):\\n partner_ids = self.get_partner_from_mail(\\n cr, uid, email_address, company_id, force_supplier=True,\\n context=local_context)\\n if partner_ids:\\n supplier_partner_id = partner_ids[0]\\n break\\n\\n # 3. Try default partner for company (company might be False):\\n if not supplier_partner_id:\\n args = [('fetchmail_invoice_default', '=', True),]\\n if company_id:\\n args.append(('company_id', '=', company_id))\\n default_ids = partner_model.search(\\n cr, uid, args, context=local_context)\\n if default_ids: # can be only one\\n supplier_partner_id = default_ids[0]\\n\\n # We should have a supplier/partner by now....\\n assert supplier_partner_id, _('No partner found to link invoice to')\\n\\n # Get company for supplier, if any. If present, should be the same\\n # as company for fetchmail config, if present. If still no\\n # company is found, use main company.\\n supplier_record = partner_model.read(\\n cr, uid, supplier_partner_id, ['company_id', 'supplier'],\\n context=local_context)\\n supplier_company_id = (\\n supplier_record['company_id'] and supplier_record['company_id'][0]\\n or False)\\n if supplier_company_id:\\n if company_id:\\n assert company_id == supplier_company_id, (_(\\n 'Supplier found not valid for company %d.') %\\n company_id)\\n else:\\n company_id = supplier_company_id\\n if not company_id:\\n # Last resort, use main company\\n company_id = base_model.get_object_reference( \\n cr, uid, 'base', 'main_company')[1]\\n \\n # Now we should have a company, and we should use it for everything\\n assert company_id, (_(\\n 'All attempts to determine company for invoice failed'))\\n local_context['force_company'] = company_id\\n \\n # Paranoid check\\n assert supplier_record['supplier'], (_(\\n 'Partner %d is not a supplier') % supplier_partner_id)\\n\\n # And we should have an account property\\n # (read again, as company might have changed)\\n supplier_record = partner_model.read(\\n cr, uid, supplier_partner_id, ['property_account_payable_id'],\\n context=local_context)\\n assert supplier_record['property_account_payable_id'], (\\n _('No account payable on partner %d.') % supplier_partner_id)\\n\\n # And we need some information in context as well\\n local_context.update({\\n 'company_id': company_id,\\n 'type': 'in_invoice',\\n })\\n\\n supplier = partner_model.browse(cr, uid, supplier_partner_id, context=local_context)\\n\\n journal_id = self.pool.get('account.invoice').default_get(cr, uid, ['journal_id'], context=local_context)['journal_id']\\n if not journal_id:\\n raise UserError(_('Please define an accounting sale journal for this company.'))\\n\\n custom_values.update({\\n 'company_id': company_id,\\n 'partner_id': supplier_partner_id,\\n 'type': 'in_invoice',\\n\\n 'account_id': supplier.property_account_payable_id.id,\\n 'journal_id': journal_id,\\n })\\n\\n\\n # custom_values.update(\\n # self.onchange_partner_id(\\n # cr, uid, [], 'in_invoice', supplier_partner_id,\\n # company_id=company_id)['value'])\\n\\n # Create the resource\\n res_id = super(account_invoice, self).message_new(\\n cr, uid, msg_dict, custom_values=custom_values,\\n context=local_context)\\n return res_id\",\n \"def _generate_email(email, name=None):\\n result = {'email': email}\\n if name:\\n result['name'] = name\\n return result\",\n \"def post(self, request):\\n # get message from request\\n message = request.POST.get('message')\\n # create message\\n ChatMessage.objects.create(\\n message=message, _from=request.user, _to=User.objects.get(pk=request.POST.get('user_id')))\\n # return response\\n return HttpResponse('success')\",\n \"def create(cls, sender, recipient, body, timestamp=None):\\n if timestamp is None:\\n timestamp = datetime.datetime.utcnow()\\n msg = cls(sender, recipient, body, timestamp)\\n db.session.add(msg)\\n\\n try:\\n db.session.commit()\\n db.session.flush()\\n return msg.id\\n except BaseException as exc:\\n db.session.rollback()\\n raise exc\",\n \"def create_message(id_user: int, message: str):\\n # Create datetime of today at midnight\\n today = datetime.date.today()\\n today = today.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n # Query to check if there is already a message for this user today\\n mycursor.execute(f\\\"\\\"\\\"SELECT id_message\\n FROM Daily_message\\n WHERE date_message >= '{today}'\\n AND id_user = {id_user}\\n \\\"\\\"\\\")\\n rowcount = mycursor.rowcount\\n if rowcount == 1:\\n # If there is already a message today, user can't add a new one\\n return 'Impossible d\\\\'ajouter ce message. Il y a déjà un message aujourd\\\\'hui, veuillez le modifier.'\\n else:\\n # Create datetime of today at current time\\n date_message = datetime.datetime.today()\\n date_message = date_message.strftime(\\\"%Y/%m/%d %H:%M:%S\\\")\\n columns_mess = 'id_user, text, date_message'\\n # Add the message infos to the Daily_message table\\n add_in_database((id_user, message, date_message), 'Daily_message', columns_mess)\\n mydb.commit()\\n # Get the id_message\\n mycursor.execute(f\\\"\\\"\\\"SELECT id_message\\n FROM Daily_message\\n WHERE (id_user = {id_user})\\n AND (date_message >= '{today}')\\n \\\"\\\"\\\")\\n infos = mycursor.fetchall()\\n id_message = infos[0][0]\\n # Fill emotion table for the new message\\n create_emotion(id_message, message)\\n return {'id_user': id_user, 'message': message}\",\n \"def create_message_talk(msg_talk_as_str):\\n msg_comps = msg_talk_as_str.split('\\\\n')\\n from_id = msg_comps[1]\\n origin_id = msg_comps[2]\\n message_id = msg_comps[3]\\n topics = msg_comps[4].split(',')\\n data = msg_comps[5]\\n return MessageTalk(from_id, origin_id, topics, data, message_id)\",\n \"def create(self, data):\\n\\n\\t\\tmessage = data\\n\\t\\tmessage[\\\"id\\\"] = self.count = self.count + 1\\n\\t\\tself.messages.append(message)\\n\\n\\t\\treturn(message)\",\n \"def send_email(self, to_address, subject, body, cc_recipients=[]):\\n\\n # Build and send message\\n msg = Message(\\n account=self.account,\\n folder=self.account.sent,\\n subject=subject,\\n body= HTMLBody(body),\\n to_recipients=[Mailbox(email_address=to_address)],\\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\\n )\\n\\n msg.send_and_save()\\n print(\\\"Message to {} sent.\\\".format(to_address))\",\n \"def _create_msg(self, tr_id, i_triples, i_type, r_triples, r_type, confirm):\\n params = SSAP_UPDATE_PARAM_TEMPLATE % (str(i_type).upper(),\\n str(i_triples),\\n str(r_type).upper(),\\n str(r_triples),\\n str(confirm).upper())\\n tmp = SSAP_MESSAGE_TEMPLATE % (str(self.node_id), str(self.targetSS),\\n self.tr_type, str(tr_id), params)\\n return tmp\",\n \"def quick_email(self, send_to, subject, body, style=None):\\n message = Message(body, style=style)\\n\\n self.send_message(message, send_to, subject)\",\n \"def get_email():\\n return Email(\\n subject='[Messages] Integration Test',\\n body='Conducting Integration Testing',\\n attachments=str(TESTDIR.joinpath('file2.png')))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8220897","0.783499","0.7542338","0.7535529","0.7519684","0.74869245","0.7417828","0.73909754","0.7373257","0.7355638","0.73106784","0.7269137","0.719846","0.7196095","0.7140178","0.7047853","0.7021525","0.70037013","0.70037013","0.68474555","0.68418366","0.6781704","0.6777992","0.6744443","0.67329454","0.6714459","0.671162","0.67051923","0.66659385","0.6665762","0.66546285","0.665063","0.6643006","0.6626429","0.6617764","0.6596703","0.65357643","0.65236783","0.6523545","0.6514001","0.6502263","0.6484727","0.6484322","0.6482396","0.6468869","0.6463164","0.6459357","0.6409988","0.6361861","0.6359212","0.6342248","0.63373715","0.6314738","0.6312374","0.6297892","0.6277734","0.6273468","0.62713385","0.62654835","0.62596893","0.6253985","0.6252849","0.62511957","0.62458163","0.6242815","0.6183823","0.61819816","0.6176082","0.6165352","0.61633307","0.61334467","0.61282927","0.61141455","0.6113214","0.6104701","0.60809094","0.6062849","0.6053299","0.6051991","0.6018882","0.6012688","0.601257","0.60062265","0.59931654","0.5989733","0.5986193","0.59848374","0.5981605","0.598052","0.5966138","0.59649146","0.5963139","0.59590113","0.5958782","0.59541005","0.5953965","0.594576","0.5932744","0.5932339","0.5930283"],"string":"[\n \"0.8220897\",\n \"0.783499\",\n \"0.7542338\",\n \"0.7535529\",\n \"0.7519684\",\n \"0.74869245\",\n \"0.7417828\",\n \"0.73909754\",\n \"0.7373257\",\n \"0.7355638\",\n \"0.73106784\",\n \"0.7269137\",\n \"0.719846\",\n \"0.7196095\",\n \"0.7140178\",\n \"0.7047853\",\n \"0.7021525\",\n \"0.70037013\",\n \"0.70037013\",\n \"0.68474555\",\n \"0.68418366\",\n \"0.6781704\",\n \"0.6777992\",\n \"0.6744443\",\n \"0.67329454\",\n \"0.6714459\",\n \"0.671162\",\n \"0.67051923\",\n \"0.66659385\",\n \"0.6665762\",\n \"0.66546285\",\n \"0.665063\",\n \"0.6643006\",\n \"0.6626429\",\n \"0.6617764\",\n \"0.6596703\",\n \"0.65357643\",\n \"0.65236783\",\n \"0.6523545\",\n \"0.6514001\",\n \"0.6502263\",\n \"0.6484727\",\n \"0.6484322\",\n \"0.6482396\",\n \"0.6468869\",\n \"0.6463164\",\n \"0.6459357\",\n \"0.6409988\",\n \"0.6361861\",\n \"0.6359212\",\n \"0.6342248\",\n \"0.63373715\",\n \"0.6314738\",\n \"0.6312374\",\n \"0.6297892\",\n \"0.6277734\",\n \"0.6273468\",\n \"0.62713385\",\n \"0.62654835\",\n \"0.62596893\",\n \"0.6253985\",\n \"0.6252849\",\n \"0.62511957\",\n \"0.62458163\",\n \"0.6242815\",\n \"0.6183823\",\n \"0.61819816\",\n \"0.6176082\",\n \"0.6165352\",\n \"0.61633307\",\n \"0.61334467\",\n \"0.61282927\",\n \"0.61141455\",\n \"0.6113214\",\n \"0.6104701\",\n \"0.60809094\",\n \"0.6062849\",\n \"0.6053299\",\n \"0.6051991\",\n \"0.6018882\",\n \"0.6012688\",\n \"0.601257\",\n \"0.60062265\",\n \"0.59931654\",\n \"0.5989733\",\n \"0.5986193\",\n \"0.59848374\",\n \"0.5981605\",\n \"0.598052\",\n \"0.5966138\",\n \"0.59649146\",\n \"0.5963139\",\n \"0.59590113\",\n \"0.5958782\",\n \"0.59541005\",\n \"0.5953965\",\n \"0.594576\",\n \"0.5932744\",\n \"0.5932339\",\n \"0.5930283\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7297086"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":9478,"cells":{"query":{"kind":"string","value":"Send an email message."},"document":{"kind":"string","value":"def send_message(message, client):\n try:\n message = (client.users().messages().send(userId='me', body=message).execute())\n print('Message Id: %s' % message['id'])\n return message\n except errors.HttpError as error:\n print('An error occurred: %s' % error)"},"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 send_email(self, message):\n pass","def send_mail(email):\n return email.send()","def send_email(msg):\n\tprint(\"sendEmail: \" + msg)","def send_email(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()","def send_email(msg):\n common_send_email(subject=msg.subject, recipients=msg.recipients, html=msg.html)","def send_message(self, message):\n try:\n msg = sg.client.mail.send.post(request_body=message)\n app.logger.info(\"{error} with {response}\".format(error=msg.status_code, response=msg.body))\n app.logger.info(\"Successfully sent message: {msg}\".format(msg=msg))\n except Exception as e:\n app.logger.exception(\"Error While sending emails: {msg}\".format(msg=message))\n app.logger.exception(e)","def send_email(self, email_from, email_to, message):\n logging.info(\"Attempting to send email from \" + email_from + \" to \" + email_to)\n self.conn.sendmail(email_from, email_to, message)\n logging.info(\"Email sent\")","def send_message():\n # @todo validation & error handling.\n sg = SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))\n log(\"Message generated and sent at {}\".format(strftime('%x %H:%M:%S')))\n sg.client.mail.send.post(request_body=build_message())","def send(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()","def send_email(my_email, password, message):\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.starttls()\n server.login(my_email, password)\n # send from my_email to my_email (from, to, message)\n server.sendmail(my_email, my_email, message)\n server.quit()","def send_mail(self, address, title, message):\n pass","def send_email(self):\n message = MIMEText(self.email_body, 'plain', 'utf-8')\n\n message['Subject'] = self.email_subject\n message['From'] = gmail_user\n message['To'] = ', '.join(self.recipients)\n\n try:\n server = smtplib.SMTP_SSL('smtp.gmail.com', 465)\n server.ehlo()\n\n server.login(gmail_user, gmail_password)\n\n server.sendmail(message['From'], self.recipients, message.as_string())\n\n server.close()\n\n print('Email sent!')\n except Exception as err:\n # TODO Write error to log file\n raise err","def send(self, email):\r\n smtp = smtplib.SMTP(self.server, self.port)\r\n smtp.ehlo()\r\n \r\n if self.tls:\r\n smtp.starttls()\r\n smtp.ehlo()\r\n\r\n if self.user and self.passwd:\r\n smtp.login(self.user, self.passwd)\r\n\r\n smtp.sendmail(email.from_address, email.to + email.ccs, str(email))\r\n if email.bccs:\r\n email.root['X-antroy-sent'] = \"True\"\r\n smtp.sendmail(email.from_address, email.bccs, str(email))\r\n del email.root['X-antroy-sent']\r\n smtp.quit()","def email(self, email_address, message):\n self.server.sendmail(self.username, email_address, message)","def send_email(subject, sender, recipients, text_body, html_body):\n\t\tmsg = Message(subject, sender=sender, recipients=recipients)\n\t\tmsg.body = text_body\n\t\tmsg.html = html_body\n\t\tmail.send(msg)","def send_email():\n send_mail(\"You've got some problem.\", 'REPAIR IT', 'dimazarj2009@rambler.ru',\n ['dimazarj2009@rambler.ru'], fail_silently=False,)","def send_mail(subject):\r\n obj = EmailNotification().emailobj()\r\n obj.send_mail(subject)","def send_email(subject, sender, recipients, text_body, html_body):\n msg = Message(subject=subject, sender=sender, recipients=recipients)\n msg.body = text_body\n msg.html = html_body\n mail.send(msg)","def send_email(self, to, subject, message):\n\n email_to = \"james@vixal.net\"\n try:\n mx_alarm = AlertEmail(email_to, self.subject, self.message)\n mx_alarm.send()\n print(\"\\t{} |{}| Successfully sent email.\".format(Timer.OK, self.tinfo['name']))\n return True\n except Exception as e:\n print(\"\\t{} Exception in send_email! {}\".format(Timer.FAIL, e))","def send_message(self, subject, body):\n headers = [\n \"From: \" + self.email,\n \"Subject: \" + subject,\n \"To: \" + self.email,\n \"MIME-Version: 1.0\",\n \"Content-Type: text/html\"]\n headers = \"\\r\\n\".join(headers)\n self.session.sendmail(\n self.email,\n self.email,\n headers + \"\\r\\n\\r\\n\" + body)","def send_message(user_id, name, user_info, subject, body):\n send_mail(subject, body, settings.SERVER_EMAIL, [\"%s <%s>\" % (name, user_id)],\n fail_silently=False, html_message=body)","def send_email(self, email):\n\n if not isinstance(email, str):\n raise TypeError('type of email must be str not %s' % type(email))\n\n message = self.get_message(email)\n self.server.send_message(message)","def send():\n try:\n data = request.get_json()\n if data['authkey'] != os.environ.get('MAIL_AUTHKEY'): \n return \"Ooops. Wrong `authkey`.\"\n msg = Message(data['subject'],\n sender=os.environ.get('MAIL_USERNAME'),\n recipients=[data['recipient']])\n msg.body = data['body'] \n mail.send(msg)\n return 'Mail sent!'\n except Exception as e:\n print('We got an error at ' + httpdate(datetime.datetime.now()))\n print(str(e)) \n return 'There was an error with that request.'","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def send_email(recipient, subject, message):\n from_email = os.getenv(\"EMAIL_SENDER\")\n status = send_mail(subject, message, from_email, [recipient])\n return status","def send_email(to_address, from_address, subject, body):\n mail = \"\"\"echo \"From: %(from)s\\r\\nDate: $(date)\\r\\nSubject: %(subject)s\\r\\nMIME-Version: 1.0\\r\\nContent-Type: text/html; charset=utf-8\\r\\n\\r\\n%(body)s\" | ssmtp %(to)s\"\"\" % {\n \"to\": to_address,\n \"from\": from_address,\n \"subject\": subject,\n \"body\": body,\n }\n cmd(mail)","def sendEmail(message):\n message_string = '\\n'.join(message)\n recipients = ['nadavo@campus.technion.ac.il', 'olegzendel@campus.technion.ac.il']\n msg = EmailMessage()\n msg['Subject'] = 'Finished training and predicting MEMM'\n msg['From'] = 'someserver@technion.ac.il'\n msg['To'] = ', '.join(recipients)\n msg.set_content(message_string)\n sender = SMTP('localhost')\n sender.send_message(msg)\n sender.quit()","def send_mail(to, sender, subject, message):\n\n msg = MIMEText(message)\n msg['From'] = sender\n msg['To'] = to\n msg['Subject'] = subject\n body = {'raw': base64.urlsafe_b64encode(msg.as_bytes()).decode()}\n MESSAGES.send(userId='me', body=body).execute()","def sending(self, message):\n sending_mail.send(sender=self.__class__, message=message)","def send_mail(self, subject):\r\n pass","def send_email(self, to, content):\r\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\r\n server.ehlo()\r\n server.starttls()\r\n server.login(self.from_, self.password)\r\n server.sendmail(self.from_, to, content)\r\n speak(\"Email has been sent Succesfully!\")\r\n return \"None\"","def send_mail(subject, message):\n \n import smtplib\n \n msg = \"\\r\\n\".join([\n \"From: \" + gmail_sender,\n \"To: \" + email_to,\n \"Subject: \" + subject,\n \"\",\n message\n ])\n\n server = smtplib.SMTP('smtp.gmail.com:587')\n server.ehlo()\n server.starttls()\n server.login(gmail_sender,gmail_password)\n server.sendmail(gmail_sender, email_to, msg)\n server.quit()","def sendEmail(_name, _email, _body):\n\n _mailer = app.config['MAIL_USERNAME']\n msg = Message(\"Contact Form\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\n msg.body = f'''{_body}\n\n\nSender's Name: {_name}\nSender's Email: {_email}\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\n'''\n mail.send(msg)\n return 'OK'","def _send_smtp(message, subject, to, to_name, sender, sender_name):\n host = app.config.get('MAIL_HOST')\n\n if not host:\n raise MailFailure('SMTP Server Not Configured')\n\n try:\n server = smtplib.SMTP(host)\n except (smtplib.SMTPConnectError, socket.error) as ex:\n app.logger.error('Unable to send mail: %s', str(ex))\n raise MailFailure('Error connecting to SMTP server.')\n\n msg = text.MIMEText(message)\n msg['Subject'] = subject\n msg['To'] = email.utils.formataddr((to_name, to))\n msg['From'] = email.utils.formataddr((sender_name, sender))\n\n try:\n if app.debug:\n server.set_debuglevel(True)\n server.sendmail(sender, [to], msg.as_string())\n except (smtplib.SMTPException, socket.error) as ex:\n app.logger.error('Unable to send mail: %s', str(ex))\n raise MailFailure('Error sending mail to SMTP server.')\n finally:\n try:\n server.quit()\n except smtplib.SMTPException:\n pass","def send_mail(self, msg):\n mail_queue.put(msg)","def send_email_via_api(self, to, subject, message):\n\n return self.mail.send(to, subject, message)","def send_email(self, to_address, subject, body, cc_recipients=[]):\n\n # Build and send message\n msg = Message(\n account=self.account,\n folder=self.account.sent,\n subject=subject,\n body= HTMLBody(body),\n to_recipients=[Mailbox(email_address=to_address)],\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\n )\n\n msg.send_and_save()\n print(\"Message to {} sent.\".format(to_address))","def quick_email(self, send_to, subject, body, style=None):\n message = Message(body, style=style)\n\n self.send_message(message, send_to, subject)","def send_email(recipient,subject,message):\n msg = MIMEText(message)\n me = 'cryolt2@gmail.com'\n \n msg['Subject'] = subject\n msg['From'] = me\n msg['To'] = recipient\n\n # Send the message via our own SMTP server, but don't include the\n # envelope header.\n username='cryolt2'\n password='Diamond=Geil!'\n\n server = smtplib.SMTP('smtp.gmail.com:587') \n server.starttls() \n server.login(username,password) \n server.sendmail(me, recipient, msg.as_string()) \n server.quit()","def send_message(self, message, send_to, subject):\n message = message.mime()\n\n message['From'] = self.email_address\n message['To'] = send_to\n\n message['Subject'] = subject\n\n self._login()\n self.server.sendmail(self.email_address, send_to, message.as_string())\n self._logout()","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send(self, address_to, message, emailSubject = \"Automated Email\", attachmentFilePath = None):\r\n\t\tmail = self._createEmail(address_to, message, emailSubject)\r\n\t\tif attachmentFilePath != None:\r\n\t\t\tmail.attachment = self._createAttachment(attachmentFilePath)\r\n\t\tsg = sendgrid.SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))\r\n\t\tresponse = sg.send(mail)\r\n\t\tif response.status_code == 202:\r\n\t\t\tprint(\"Email sent\")\r\n\t\telse:\r\n\t\t\tprint(\"Email not sent. Please check error codes below - \")\r\n\t\t\tprint(response.status_code)\r\n\t\t\tprint(response.headers)","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.email])","def email_user(self, subject, message, from_email=None, **kwargs):\r\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\r\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_mail(self, html):\n message = Message(\n From=self._config['mail']['address'], To=self._config['mail']['to'],\n Subject=self._config['mail']['subject']\n )\n message.Html = html\n return self.sender.send(message)","def send_mail(from_email, to_emails, subject, plain_body, html_body):\n\n # Implementation goes here\n # ...","def test_send_email(self):\n\t\trecipient = \"\"\n\t\tself.email.send_email(self.subject, recipient, self.content)","def email_user(self, subject: str, message: str, from_email: str = None) -> None:\n send_mail(subject, message, from_email, [self.email])","def sent(self, message):\n sent_mail.send(sender=self.__class__, message=message)","def send_email(subject, text):\n url = ('https://api.mailgun.net/v3/%s/messages' %\n cfg('mail:mailgun_domain'))\n auth = ('api', cfg('mail:mailgun_key'))\n data = {'from': 'Akari Bot <%s>' % cfg('mail:from'),\n 'to': [cfg('mail:to')],\n 'subject': subject, 'text': text}\n return requests.post(url, auth=auth, data=data)","def _send(message: Message, application: Flask) -> None:\n\n with application.app_context():\n mail.send(message)","def email_user(self, subject, message, from_email=None):\n\t\tsend_mail(subject, message, from_email, [self.email])","def send_email(request):\n # send emails and return some manner of success response\n send(**request.params)\n return {'success': 'mail sent!'}","def send_email(self):\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.ehlo()\n server.login(\"sunnysunita.com@gmail.com\", \"tdcvgycwrzthjqgj\")\n\n subject = \"Price Fell Down\"\n body = \"Check the amazon link \" + self.__product_URL\n message = f\"Subject: {subject}\\n\\n{body}\"\n server.sendmail(\n \"sunnysunita.com@gmail.com\",\n self.__email,\n message\n )\n #print(\"Our mail is sent!!!!\")","def email_user(self, subject, message, from_email=None, **kwargs):\n\t\tsend_mail(subject, message, from_email, [self.email], **kwargs)","def email_to_user(self, subject, message, sender=None, **kwargs):\n send_mail(subject, message, sender, [self.email], **kwargs)","def send(self):\n return send_mail(self.subject, self.message, self.sender, self.recipients, fail_silently=False)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def email_user(self, subject, message, from_email=None, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_async_email(self, msg):\n with app.app_context():\n result = mail.send(msg)\n print result","def send_email(sender: str, password: str) -> None:\r\n\r\n # Check for a email and password\r\n if not sender or not password:\r\n print('A recipent or password was not supplied')\r\n exit(1)\r\n \r\n initialize_server()\r\n\r\n webserver.login(sender, password)\r\n webserver.send_message(message)\r\n webserver.quit()","def sendEmail(recipient, content):\n server = smtplib.SMTP(\"smtp@gmail.com\", 587)\n server.ehlo()\n server.starttls()\n server.login(\"youremail@gmail.com\", \"password\")\n server.sendmail(\"youremail@gmail.com\", recipient, content)\n server.close()","def send(self):\n logger.debug('Sending Email')\n self.mimepgp.send()","def send_email(subject, message):\n email_from = config.get('email', 'email_from')\n email_to = config.get('email', 'email_to')\n email_password = config.get('email', 'email_password')\n msg = MIMEMultipart()\n msg['From'] = email_from\n msg['To'] = email_to\n msg['Subject'] = subject\n body = message\n msg.attach(MIMEText(body, 'plain'))\n\n server = smtplib.SMTP(config.get('email', 'smtp_server'))\n server.ehlo()\n server.starttls()\n server.login(email_from, email_password)\n text = msg.as_string()\n server.sendmail(email_from, email_to, text)\n server.quit()","def simple_send_email(sender, recipient, subject, message, server=EMAIL_HOST, port=EMAIL_PORT):\n headers = [\"From: \" + sender,\n \"Subject: \" + subject,\n \"To: \" + recipient,\n \"MIME-Version: 1.0\",\n \"Content-Type: text/plain\"]\n headers = \"\\r\\n\".join(headers)\n\n session = smtplib.SMTP(server, port)\n\n session.ehlo()\n session.starttls()\n session.ehlo()\n session.login(EMAIL_HOST_USER, EMAIL_HOST_PASSWORD)\n\n session.sendmail(sender, recipient, headers + \"\\r\\n\\r\\n\" + message)\n session.close()","def send_test_email():\n from flask_mail import Message\n from website.core import mail\n\n to = ['no-reply@mikefromit.com']\n subject = 'Test Email'\n template = '<h1>You Ok?</h1>'\n\n msg = Message(\n subject,\n recipients=to,\n html=template,\n sender=current_app.config['SECURITY_EMAIL_SENDER']\n )\n mail.send(msg)","def __send_message(self, message):\n logging.debug(\"Sending message\")\n try:\n message = self.__email_api.messages.send(message=message)\n return message\n except Error as error:\n logging.error('An error occurred emailing a user: {0}'.format(error))\n raise error","def send(self, email):\n client = self.clients[email.addressee]\n client.receive(email)","def send_email(recipient, subject, body) -> None:\n port = 465\n smtp_server = \"smtp.gmail.com\"\n sender_email = user['username']\n password = user['password']\n\n message = MIMEMultipart()\n message['From'] = sender_email\n message['To'] = recipient\n message['Subject'] = subject\n body = MIMEText(body) \n message.attach(body)\n\n server = smtplib.SMTP_SSL(smtp_server, port)\n server.login(sender_email, password)\n server.sendmail(sender_email, recipient, message.as_string())\n server.quit()","def send_mail(self):\n try:\n mail = smtplib.SMTP('smtp.gmail.com', 587)\n mail.ehlo()\n mail.starttls()\n mail.login(self.mail_user, self.mail_pass)\n content = \"Subject: Test %s %s on host %s\\n\\n%s\\n logs are save at localhost path:\\n%s\" % (\n self.test_name, self.event, self.host_name, self.event_details, self.log_path\n )\n mail.sendmail(self.mail_user, self.target_mail, content)\n mail.close()\n except Exception as e:\n self.logger.error(\"Sending mail failed with Error %s\", e)\n\n else:\n self.logger.info(\"Mail sent to %s\", self.target_mail)","def email_user(self, subject, message,\n from_email=settings.DEFAULT_FROM_EMAIL, **kwargs):\n send_mail(subject, message, from_email, [self.email], **kwargs)","def send_email(subject, body, mail_to, reply_to=None):\n email_message = EmailMessage(\n subject=settings.EMAIL_SUBJECT.format(subject),\n body=body,\n from_email=settings.DEFAULT_FROM_EMAIL,\n to=mail_to,\n reply_to=reply_to,\n )\n email_message.content_subtype = 'html'\n email_message.send()","def _send(self, email_message):\n if not email_message.to:\n return False\n try:\n if (isinstance(email_message,gmail.EmailMessage)):\n e = message\n elif (isinstance(email_message,mail.EmailMessage)):\n e = gmail.EmailMessage(sender=email_message.from_email,\n to=email_message.to,\n subject=email_message.subject,\n body=email_message.body)\n if email_message.extra_headers.get('Reply-To', None):\n e.reply_to = email_message.extra_headers['Reply-To']\n if email_message.bcc:\n e.bcc = list(email_message.bcc)\n #TODO - add support for html messages and attachments...\n e.send()\n except:\n if not self.fail_silently:\n raise\n return False\n return True","def send_email(email_subject, recipient, message, config = None):\n try:\n config = current_app.config\n except:\n config = config\n\n sender = sendgrid.SendGridClient(config['SENDGRID_API_KEY'])\n\n email = sendgrid.Mail()\n\n email.set_subject(email_subject)\n email.add_to(recipient)\n email.set_from(config['FROM_EMAIL'])\n email.set_from_name(config['FROM_NAME'])\n email.set_replyto(config['FROM_NAME'])\n email.set_html(message)\n\n status, msg = sender.send(email)\n\n return status, msg","def mail_send():\n report_file_path = (\n f'{os.path.abspath(\".\")}/{Common.get_config_value(\"report_location\")}'\n )\n with open(f\"{report_file_path}/subject\", \"rb\") as subject_handler:\n subject = pickle.load(subject_handler)\n with open(f\"{report_file_path}/{'recipient'}\", \"rb\") as recipient_handler:\n recipient = pickle.load(recipient_handler)\n report_file_path = (\n f\"{os.path.abspath('.')}/{Common.get_config_value('report_location')}\"\n )\n try:\n if os.path.isfile(f\"{report_file_path}/mail_report.html\"):\n os.popen(\n f\"ssh -i {Common.get_config_value('build_server_pemfile')} \"\n f\"-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no\"\n f\" root@{Common.get_config_value('build_server_hostname')}\"\n f\" {Common.get_config_value('mail_script_location')}/\"\n f\"{Common.get_config_value('mail_script_name')} \"\n f\"{subject} {recipient}\"\n )\n Common.logger.info(\"Mail send successfully\")\n except Exception as ex:\n Common.logger.warning(f\"Mail sent failed due to exception: {ex}\")","def send_email(self, text):\n msg_text = MIMEText(text)\n msg_text['Subject'] = '[WebSite Watchdog] Failure'\n msg_text['From'] = self.from_email\n msg_text['To'] = self.to_email\n \n s = smtplib.SMTP(self.smtp_server)\n s.sendmail(self.from_email, [self.to_email], msg_text.as_string())\n s.quit()","def _send_mail(self, subject, content, email):\n msg = MIMEText(content, 'plain', 'utf-8')\n\n msg['Subject'] = '%s' % (subject)\n msg['From'] = email\n msg['To'] = self._get_config_value('email', 'toemail')\n\n try:\n smtp_conn = SMTP('localhost')\n smtp_conn.sendmail(msg['From'], [msg['To']], msg.as_string())\n smtp_conn.quit()\n except (socket.error, SMTPException), e:\n self._logger.error('Mail could not be sent (%s)' % e)\n return False\n return True","def email_user(self, subject, message, from_email=None):\n send_mail(subject, message, from_email, [self.username])","def send_email(email: str, subject: str, message_body: str) -> bool:\n message = Mail(\n from_email=\"notifications@grocery.com\",\n to_emails=email,\n subject=subject,\n plain_text_content=message_body,\n )\n sg = SendGridAPIClient(os.environ.get(\"SENDGRID_API_KEY\"))\n sg.send(message)\n return True"],"string":"[\n \"def send_email(self, message):\\n pass\",\n \"def send_mail(email):\\n return email.send()\",\n \"def send_email(msg):\\n\\tprint(\\\"sendEmail: \\\" + msg)\",\n \"def send_email(message):\\n mail_server = smtplib.SMTP('localhost')\\n mail_server.send_message(message)\\n mail_server.quit()\",\n \"def send_email(msg):\\n common_send_email(subject=msg.subject, recipients=msg.recipients, html=msg.html)\",\n \"def send_message(self, message):\\n try:\\n msg = sg.client.mail.send.post(request_body=message)\\n app.logger.info(\\\"{error} with {response}\\\".format(error=msg.status_code, response=msg.body))\\n app.logger.info(\\\"Successfully sent message: {msg}\\\".format(msg=msg))\\n except Exception as e:\\n app.logger.exception(\\\"Error While sending emails: {msg}\\\".format(msg=message))\\n app.logger.exception(e)\",\n \"def send_email(self, email_from, email_to, message):\\n logging.info(\\\"Attempting to send email from \\\" + email_from + \\\" to \\\" + email_to)\\n self.conn.sendmail(email_from, email_to, message)\\n logging.info(\\\"Email sent\\\")\",\n \"def send_message():\\n # @todo validation & error handling.\\n sg = SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))\\n log(\\\"Message generated and sent at {}\\\".format(strftime('%x %H:%M:%S')))\\n sg.client.mail.send.post(request_body=build_message())\",\n \"def send(message):\\n mail_server = smtplib.SMTP('localhost')\\n mail_server.send_message(message)\\n mail_server.quit()\",\n \"def send_email(my_email, password, message):\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.starttls()\\n server.login(my_email, password)\\n # send from my_email to my_email (from, to, message)\\n server.sendmail(my_email, my_email, message)\\n server.quit()\",\n \"def send_mail(self, address, title, message):\\n pass\",\n \"def send_email(self):\\n message = MIMEText(self.email_body, 'plain', 'utf-8')\\n\\n message['Subject'] = self.email_subject\\n message['From'] = gmail_user\\n message['To'] = ', '.join(self.recipients)\\n\\n try:\\n server = smtplib.SMTP_SSL('smtp.gmail.com', 465)\\n server.ehlo()\\n\\n server.login(gmail_user, gmail_password)\\n\\n server.sendmail(message['From'], self.recipients, message.as_string())\\n\\n server.close()\\n\\n print('Email sent!')\\n except Exception as err:\\n # TODO Write error to log file\\n raise err\",\n \"def send(self, email):\\r\\n smtp = smtplib.SMTP(self.server, self.port)\\r\\n smtp.ehlo()\\r\\n \\r\\n if self.tls:\\r\\n smtp.starttls()\\r\\n smtp.ehlo()\\r\\n\\r\\n if self.user and self.passwd:\\r\\n smtp.login(self.user, self.passwd)\\r\\n\\r\\n smtp.sendmail(email.from_address, email.to + email.ccs, str(email))\\r\\n if email.bccs:\\r\\n email.root['X-antroy-sent'] = \\\"True\\\"\\r\\n smtp.sendmail(email.from_address, email.bccs, str(email))\\r\\n del email.root['X-antroy-sent']\\r\\n smtp.quit()\",\n \"def email(self, email_address, message):\\n self.server.sendmail(self.username, email_address, message)\",\n \"def send_email(subject, sender, recipients, text_body, html_body):\\n\\t\\tmsg = Message(subject, sender=sender, recipients=recipients)\\n\\t\\tmsg.body = text_body\\n\\t\\tmsg.html = html_body\\n\\t\\tmail.send(msg)\",\n \"def send_email():\\n send_mail(\\\"You've got some problem.\\\", 'REPAIR IT', 'dimazarj2009@rambler.ru',\\n ['dimazarj2009@rambler.ru'], fail_silently=False,)\",\n \"def send_mail(subject):\\r\\n obj = EmailNotification().emailobj()\\r\\n obj.send_mail(subject)\",\n \"def send_email(subject, sender, recipients, text_body, html_body):\\n msg = Message(subject=subject, sender=sender, recipients=recipients)\\n msg.body = text_body\\n msg.html = html_body\\n mail.send(msg)\",\n \"def send_email(self, to, subject, message):\\n\\n email_to = \\\"james@vixal.net\\\"\\n try:\\n mx_alarm = AlertEmail(email_to, self.subject, self.message)\\n mx_alarm.send()\\n print(\\\"\\\\t{} |{}| Successfully sent email.\\\".format(Timer.OK, self.tinfo['name']))\\n return True\\n except Exception as e:\\n print(\\\"\\\\t{} Exception in send_email! {}\\\".format(Timer.FAIL, e))\",\n \"def send_message(self, subject, body):\\n headers = [\\n \\\"From: \\\" + self.email,\\n \\\"Subject: \\\" + subject,\\n \\\"To: \\\" + self.email,\\n \\\"MIME-Version: 1.0\\\",\\n \\\"Content-Type: text/html\\\"]\\n headers = \\\"\\\\r\\\\n\\\".join(headers)\\n self.session.sendmail(\\n self.email,\\n self.email,\\n headers + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + body)\",\n \"def send_message(user_id, name, user_info, subject, body):\\n send_mail(subject, body, settings.SERVER_EMAIL, [\\\"%s <%s>\\\" % (name, user_id)],\\n fail_silently=False, html_message=body)\",\n \"def send_email(self, email):\\n\\n if not isinstance(email, str):\\n raise TypeError('type of email must be str not %s' % type(email))\\n\\n message = self.get_message(email)\\n self.server.send_message(message)\",\n \"def send():\\n try:\\n data = request.get_json()\\n if data['authkey'] != os.environ.get('MAIL_AUTHKEY'): \\n return \\\"Ooops. Wrong `authkey`.\\\"\\n msg = Message(data['subject'],\\n sender=os.environ.get('MAIL_USERNAME'),\\n recipients=[data['recipient']])\\n msg.body = data['body'] \\n mail.send(msg)\\n return 'Mail sent!'\\n except Exception as e:\\n print('We got an error at ' + httpdate(datetime.datetime.now()))\\n print(str(e)) \\n return 'There was an error with that request.'\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def send_email(recipient, subject, message):\\n from_email = os.getenv(\\\"EMAIL_SENDER\\\")\\n status = send_mail(subject, message, from_email, [recipient])\\n return status\",\n \"def send_email(to_address, from_address, subject, body):\\n mail = \\\"\\\"\\\"echo \\\"From: %(from)s\\\\r\\\\nDate: $(date)\\\\r\\\\nSubject: %(subject)s\\\\r\\\\nMIME-Version: 1.0\\\\r\\\\nContent-Type: text/html; charset=utf-8\\\\r\\\\n\\\\r\\\\n%(body)s\\\" | ssmtp %(to)s\\\"\\\"\\\" % {\\n \\\"to\\\": to_address,\\n \\\"from\\\": from_address,\\n \\\"subject\\\": subject,\\n \\\"body\\\": body,\\n }\\n cmd(mail)\",\n \"def sendEmail(message):\\n message_string = '\\\\n'.join(message)\\n recipients = ['nadavo@campus.technion.ac.il', 'olegzendel@campus.technion.ac.il']\\n msg = EmailMessage()\\n msg['Subject'] = 'Finished training and predicting MEMM'\\n msg['From'] = 'someserver@technion.ac.il'\\n msg['To'] = ', '.join(recipients)\\n msg.set_content(message_string)\\n sender = SMTP('localhost')\\n sender.send_message(msg)\\n sender.quit()\",\n \"def send_mail(to, sender, subject, message):\\n\\n msg = MIMEText(message)\\n msg['From'] = sender\\n msg['To'] = to\\n msg['Subject'] = subject\\n body = {'raw': base64.urlsafe_b64encode(msg.as_bytes()).decode()}\\n MESSAGES.send(userId='me', body=body).execute()\",\n \"def sending(self, message):\\n sending_mail.send(sender=self.__class__, message=message)\",\n \"def send_mail(self, subject):\\r\\n pass\",\n \"def send_email(self, to, content):\\r\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\r\\n server.ehlo()\\r\\n server.starttls()\\r\\n server.login(self.from_, self.password)\\r\\n server.sendmail(self.from_, to, content)\\r\\n speak(\\\"Email has been sent Succesfully!\\\")\\r\\n return \\\"None\\\"\",\n \"def send_mail(subject, message):\\n \\n import smtplib\\n \\n msg = \\\"\\\\r\\\\n\\\".join([\\n \\\"From: \\\" + gmail_sender,\\n \\\"To: \\\" + email_to,\\n \\\"Subject: \\\" + subject,\\n \\\"\\\",\\n message\\n ])\\n\\n server = smtplib.SMTP('smtp.gmail.com:587')\\n server.ehlo()\\n server.starttls()\\n server.login(gmail_sender,gmail_password)\\n server.sendmail(gmail_sender, email_to, msg)\\n server.quit()\",\n \"def sendEmail(_name, _email, _body):\\n\\n _mailer = app.config['MAIL_USERNAME']\\n msg = Message(\\\"Contact Form\\\", sender=('iSOLveIT Contact', f'{_mailer}'), recipients=[f'{_mailer}'])\\n msg.body = f'''{_body}\\n\\n\\nSender's Name: {_name}\\nSender's Email: {_email}\\nDate Sent: {dt.now(tz=GMT_tz).strftime('%B %d, %Y, %H:%M ') + 'GMT'}\\n'''\\n mail.send(msg)\\n return 'OK'\",\n \"def _send_smtp(message, subject, to, to_name, sender, sender_name):\\n host = app.config.get('MAIL_HOST')\\n\\n if not host:\\n raise MailFailure('SMTP Server Not Configured')\\n\\n try:\\n server = smtplib.SMTP(host)\\n except (smtplib.SMTPConnectError, socket.error) as ex:\\n app.logger.error('Unable to send mail: %s', str(ex))\\n raise MailFailure('Error connecting to SMTP server.')\\n\\n msg = text.MIMEText(message)\\n msg['Subject'] = subject\\n msg['To'] = email.utils.formataddr((to_name, to))\\n msg['From'] = email.utils.formataddr((sender_name, sender))\\n\\n try:\\n if app.debug:\\n server.set_debuglevel(True)\\n server.sendmail(sender, [to], msg.as_string())\\n except (smtplib.SMTPException, socket.error) as ex:\\n app.logger.error('Unable to send mail: %s', str(ex))\\n raise MailFailure('Error sending mail to SMTP server.')\\n finally:\\n try:\\n server.quit()\\n except smtplib.SMTPException:\\n pass\",\n \"def send_mail(self, msg):\\n mail_queue.put(msg)\",\n \"def send_email_via_api(self, to, subject, message):\\n\\n return self.mail.send(to, subject, message)\",\n \"def send_email(self, to_address, subject, body, cc_recipients=[]):\\n\\n # Build and send message\\n msg = Message(\\n account=self.account,\\n folder=self.account.sent,\\n subject=subject,\\n body= HTMLBody(body),\\n to_recipients=[Mailbox(email_address=to_address)],\\n cc_recipients=[(Mailbox(email_address=x)) for x in cc_recipients]\\n )\\n\\n msg.send_and_save()\\n print(\\\"Message to {} sent.\\\".format(to_address))\",\n \"def quick_email(self, send_to, subject, body, style=None):\\n message = Message(body, style=style)\\n\\n self.send_message(message, send_to, subject)\",\n \"def send_email(recipient,subject,message):\\n msg = MIMEText(message)\\n me = 'cryolt2@gmail.com'\\n \\n msg['Subject'] = subject\\n msg['From'] = me\\n msg['To'] = recipient\\n\\n # Send the message via our own SMTP server, but don't include the\\n # envelope header.\\n username='cryolt2'\\n password='Diamond=Geil!'\\n\\n server = smtplib.SMTP('smtp.gmail.com:587') \\n server.starttls() \\n server.login(username,password) \\n server.sendmail(me, recipient, msg.as_string()) \\n server.quit()\",\n \"def send_message(self, message, send_to, subject):\\n message = message.mime()\\n\\n message['From'] = self.email_address\\n message['To'] = send_to\\n\\n message['Subject'] = subject\\n\\n self._login()\\n self.server.sendmail(self.email_address, send_to, message.as_string())\\n self._logout()\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send(self, address_to, message, emailSubject = \\\"Automated Email\\\", attachmentFilePath = None):\\r\\n\\t\\tmail = self._createEmail(address_to, message, emailSubject)\\r\\n\\t\\tif attachmentFilePath != None:\\r\\n\\t\\t\\tmail.attachment = self._createAttachment(attachmentFilePath)\\r\\n\\t\\tsg = sendgrid.SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))\\r\\n\\t\\tresponse = sg.send(mail)\\r\\n\\t\\tif response.status_code == 202:\\r\\n\\t\\t\\tprint(\\\"Email sent\\\")\\r\\n\\t\\telse:\\r\\n\\t\\t\\tprint(\\\"Email not sent. Please check error codes below - \\\")\\r\\n\\t\\t\\tprint(response.status_code)\\r\\n\\t\\t\\tprint(response.headers)\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.email])\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\r\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\r\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_mail(self, html):\\n message = Message(\\n From=self._config['mail']['address'], To=self._config['mail']['to'],\\n Subject=self._config['mail']['subject']\\n )\\n message.Html = html\\n return self.sender.send(message)\",\n \"def send_mail(from_email, to_emails, subject, plain_body, html_body):\\n\\n # Implementation goes here\\n # ...\",\n \"def test_send_email(self):\\n\\t\\trecipient = \\\"\\\"\\n\\t\\tself.email.send_email(self.subject, recipient, self.content)\",\n \"def email_user(self, subject: str, message: str, from_email: str = None) -> None:\\n send_mail(subject, message, from_email, [self.email])\",\n \"def sent(self, message):\\n sent_mail.send(sender=self.__class__, message=message)\",\n \"def send_email(subject, text):\\n url = ('https://api.mailgun.net/v3/%s/messages' %\\n cfg('mail:mailgun_domain'))\\n auth = ('api', cfg('mail:mailgun_key'))\\n data = {'from': 'Akari Bot <%s>' % cfg('mail:from'),\\n 'to': [cfg('mail:to')],\\n 'subject': subject, 'text': text}\\n return requests.post(url, auth=auth, data=data)\",\n \"def _send(message: Message, application: Flask) -> None:\\n\\n with application.app_context():\\n mail.send(message)\",\n \"def email_user(self, subject, message, from_email=None):\\n\\t\\tsend_mail(subject, message, from_email, [self.email])\",\n \"def send_email(request):\\n # send emails and return some manner of success response\\n send(**request.params)\\n return {'success': 'mail sent!'}\",\n \"def send_email(self):\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.ehlo()\\n server.starttls()\\n server.ehlo()\\n server.login(\\\"sunnysunita.com@gmail.com\\\", \\\"tdcvgycwrzthjqgj\\\")\\n\\n subject = \\\"Price Fell Down\\\"\\n body = \\\"Check the amazon link \\\" + self.__product_URL\\n message = f\\\"Subject: {subject}\\\\n\\\\n{body}\\\"\\n server.sendmail(\\n \\\"sunnysunita.com@gmail.com\\\",\\n self.__email,\\n message\\n )\\n #print(\\\"Our mail is sent!!!!\\\")\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n\\t\\tsend_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_to_user(self, subject, message, sender=None, **kwargs):\\n send_mail(subject, message, sender, [self.email], **kwargs)\",\n \"def send(self):\\n return send_mail(self.subject, self.message, self.sender, self.recipients, fail_silently=False)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def email_user(self, subject, message, from_email=None, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_async_email(self, msg):\\n with app.app_context():\\n result = mail.send(msg)\\n print result\",\n \"def send_email(sender: str, password: str) -> None:\\r\\n\\r\\n # Check for a email and password\\r\\n if not sender or not password:\\r\\n print('A recipent or password was not supplied')\\r\\n exit(1)\\r\\n \\r\\n initialize_server()\\r\\n\\r\\n webserver.login(sender, password)\\r\\n webserver.send_message(message)\\r\\n webserver.quit()\",\n \"def sendEmail(recipient, content):\\n server = smtplib.SMTP(\\\"smtp@gmail.com\\\", 587)\\n server.ehlo()\\n server.starttls()\\n server.login(\\\"youremail@gmail.com\\\", \\\"password\\\")\\n server.sendmail(\\\"youremail@gmail.com\\\", recipient, content)\\n server.close()\",\n \"def send(self):\\n logger.debug('Sending Email')\\n self.mimepgp.send()\",\n \"def send_email(subject, message):\\n email_from = config.get('email', 'email_from')\\n email_to = config.get('email', 'email_to')\\n email_password = config.get('email', 'email_password')\\n msg = MIMEMultipart()\\n msg['From'] = email_from\\n msg['To'] = email_to\\n msg['Subject'] = subject\\n body = message\\n msg.attach(MIMEText(body, 'plain'))\\n\\n server = smtplib.SMTP(config.get('email', 'smtp_server'))\\n server.ehlo()\\n server.starttls()\\n server.login(email_from, email_password)\\n text = msg.as_string()\\n server.sendmail(email_from, email_to, text)\\n server.quit()\",\n \"def simple_send_email(sender, recipient, subject, message, server=EMAIL_HOST, port=EMAIL_PORT):\\n headers = [\\\"From: \\\" + sender,\\n \\\"Subject: \\\" + subject,\\n \\\"To: \\\" + recipient,\\n \\\"MIME-Version: 1.0\\\",\\n \\\"Content-Type: text/plain\\\"]\\n headers = \\\"\\\\r\\\\n\\\".join(headers)\\n\\n session = smtplib.SMTP(server, port)\\n\\n session.ehlo()\\n session.starttls()\\n session.ehlo()\\n session.login(EMAIL_HOST_USER, EMAIL_HOST_PASSWORD)\\n\\n session.sendmail(sender, recipient, headers + \\\"\\\\r\\\\n\\\\r\\\\n\\\" + message)\\n session.close()\",\n \"def send_test_email():\\n from flask_mail import Message\\n from website.core import mail\\n\\n to = ['no-reply@mikefromit.com']\\n subject = 'Test Email'\\n template = '<h1>You Ok?</h1>'\\n\\n msg = Message(\\n subject,\\n recipients=to,\\n html=template,\\n sender=current_app.config['SECURITY_EMAIL_SENDER']\\n )\\n mail.send(msg)\",\n \"def __send_message(self, message):\\n logging.debug(\\\"Sending message\\\")\\n try:\\n message = self.__email_api.messages.send(message=message)\\n return message\\n except Error as error:\\n logging.error('An error occurred emailing a user: {0}'.format(error))\\n raise error\",\n \"def send(self, email):\\n client = self.clients[email.addressee]\\n client.receive(email)\",\n \"def send_email(recipient, subject, body) -> None:\\n port = 465\\n smtp_server = \\\"smtp.gmail.com\\\"\\n sender_email = user['username']\\n password = user['password']\\n\\n message = MIMEMultipart()\\n message['From'] = sender_email\\n message['To'] = recipient\\n message['Subject'] = subject\\n body = MIMEText(body) \\n message.attach(body)\\n\\n server = smtplib.SMTP_SSL(smtp_server, port)\\n server.login(sender_email, password)\\n server.sendmail(sender_email, recipient, message.as_string())\\n server.quit()\",\n \"def send_mail(self):\\n try:\\n mail = smtplib.SMTP('smtp.gmail.com', 587)\\n mail.ehlo()\\n mail.starttls()\\n mail.login(self.mail_user, self.mail_pass)\\n content = \\\"Subject: Test %s %s on host %s\\\\n\\\\n%s\\\\n logs are save at localhost path:\\\\n%s\\\" % (\\n self.test_name, self.event, self.host_name, self.event_details, self.log_path\\n )\\n mail.sendmail(self.mail_user, self.target_mail, content)\\n mail.close()\\n except Exception as e:\\n self.logger.error(\\\"Sending mail failed with Error %s\\\", e)\\n\\n else:\\n self.logger.info(\\\"Mail sent to %s\\\", self.target_mail)\",\n \"def email_user(self, subject, message,\\n from_email=settings.DEFAULT_FROM_EMAIL, **kwargs):\\n send_mail(subject, message, from_email, [self.email], **kwargs)\",\n \"def send_email(subject, body, mail_to, reply_to=None):\\n email_message = EmailMessage(\\n subject=settings.EMAIL_SUBJECT.format(subject),\\n body=body,\\n from_email=settings.DEFAULT_FROM_EMAIL,\\n to=mail_to,\\n reply_to=reply_to,\\n )\\n email_message.content_subtype = 'html'\\n email_message.send()\",\n \"def _send(self, email_message):\\n if not email_message.to:\\n return False\\n try:\\n if (isinstance(email_message,gmail.EmailMessage)):\\n e = message\\n elif (isinstance(email_message,mail.EmailMessage)):\\n e = gmail.EmailMessage(sender=email_message.from_email,\\n to=email_message.to,\\n subject=email_message.subject,\\n body=email_message.body)\\n if email_message.extra_headers.get('Reply-To', None):\\n e.reply_to = email_message.extra_headers['Reply-To']\\n if email_message.bcc:\\n e.bcc = list(email_message.bcc)\\n #TODO - add support for html messages and attachments...\\n e.send()\\n except:\\n if not self.fail_silently:\\n raise\\n return False\\n return True\",\n \"def send_email(email_subject, recipient, message, config = None):\\n try:\\n config = current_app.config\\n except:\\n config = config\\n\\n sender = sendgrid.SendGridClient(config['SENDGRID_API_KEY'])\\n\\n email = sendgrid.Mail()\\n\\n email.set_subject(email_subject)\\n email.add_to(recipient)\\n email.set_from(config['FROM_EMAIL'])\\n email.set_from_name(config['FROM_NAME'])\\n email.set_replyto(config['FROM_NAME'])\\n email.set_html(message)\\n\\n status, msg = sender.send(email)\\n\\n return status, msg\",\n \"def mail_send():\\n report_file_path = (\\n f'{os.path.abspath(\\\".\\\")}/{Common.get_config_value(\\\"report_location\\\")}'\\n )\\n with open(f\\\"{report_file_path}/subject\\\", \\\"rb\\\") as subject_handler:\\n subject = pickle.load(subject_handler)\\n with open(f\\\"{report_file_path}/{'recipient'}\\\", \\\"rb\\\") as recipient_handler:\\n recipient = pickle.load(recipient_handler)\\n report_file_path = (\\n f\\\"{os.path.abspath('.')}/{Common.get_config_value('report_location')}\\\"\\n )\\n try:\\n if os.path.isfile(f\\\"{report_file_path}/mail_report.html\\\"):\\n os.popen(\\n f\\\"ssh -i {Common.get_config_value('build_server_pemfile')} \\\"\\n f\\\"-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no\\\"\\n f\\\" root@{Common.get_config_value('build_server_hostname')}\\\"\\n f\\\" {Common.get_config_value('mail_script_location')}/\\\"\\n f\\\"{Common.get_config_value('mail_script_name')} \\\"\\n f\\\"{subject} {recipient}\\\"\\n )\\n Common.logger.info(\\\"Mail send successfully\\\")\\n except Exception as ex:\\n Common.logger.warning(f\\\"Mail sent failed due to exception: {ex}\\\")\",\n \"def send_email(self, text):\\n msg_text = MIMEText(text)\\n msg_text['Subject'] = '[WebSite Watchdog] Failure'\\n msg_text['From'] = self.from_email\\n msg_text['To'] = self.to_email\\n \\n s = smtplib.SMTP(self.smtp_server)\\n s.sendmail(self.from_email, [self.to_email], msg_text.as_string())\\n s.quit()\",\n \"def _send_mail(self, subject, content, email):\\n msg = MIMEText(content, 'plain', 'utf-8')\\n\\n msg['Subject'] = '%s' % (subject)\\n msg['From'] = email\\n msg['To'] = self._get_config_value('email', 'toemail')\\n\\n try:\\n smtp_conn = SMTP('localhost')\\n smtp_conn.sendmail(msg['From'], [msg['To']], msg.as_string())\\n smtp_conn.quit()\\n except (socket.error, SMTPException), e:\\n self._logger.error('Mail could not be sent (%s)' % e)\\n return False\\n return True\",\n \"def email_user(self, subject, message, from_email=None):\\n send_mail(subject, message, from_email, [self.username])\",\n \"def send_email(email: str, subject: str, message_body: str) -> bool:\\n message = Mail(\\n from_email=\\\"notifications@grocery.com\\\",\\n to_emails=email,\\n subject=subject,\\n plain_text_content=message_body,\\n )\\n sg = SendGridAPIClient(os.environ.get(\\\"SENDGRID_API_KEY\\\"))\\n sg.send(message)\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8239757","0.80890095","0.79037267","0.78920776","0.7768939","0.7730623","0.7727504","0.76961035","0.76466435","0.7635667","0.7613354","0.7608988","0.7607686","0.7554999","0.7533295","0.7488125","0.74320126","0.74103194","0.7409468","0.7407818","0.7407659","0.7379054","0.73781234","0.7377925","0.7371525","0.73646206","0.7337151","0.733522","0.73204684","0.7319344","0.7315561","0.7312886","0.72968775","0.7276211","0.7274837","0.72666043","0.72538304","0.72514015","0.72259086","0.72171575","0.7209841","0.72038347","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203337","0.7203047","0.7203047","0.7188015","0.71835506","0.7174273","0.7171283","0.71695065","0.7169298","0.7150135","0.7144315","0.71131754","0.7108381","0.70906496","0.7089287","0.7087746","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.7068474","0.70606685","0.70528996","0.7043591","0.7036554","0.70276695","0.701519","0.7012193","0.70107424","0.7001337","0.70003504","0.69914514","0.6991162","0.69862646","0.6980836","0.69771427","0.6975864","0.69592273","0.6957208","0.6956571","0.69260556"],"string":"[\n \"0.8239757\",\n \"0.80890095\",\n \"0.79037267\",\n \"0.78920776\",\n \"0.7768939\",\n \"0.7730623\",\n \"0.7727504\",\n \"0.76961035\",\n \"0.76466435\",\n \"0.7635667\",\n \"0.7613354\",\n \"0.7608988\",\n \"0.7607686\",\n \"0.7554999\",\n \"0.7533295\",\n \"0.7488125\",\n \"0.74320126\",\n \"0.74103194\",\n \"0.7409468\",\n \"0.7407818\",\n \"0.7407659\",\n \"0.7379054\",\n \"0.73781234\",\n \"0.7377925\",\n \"0.7371525\",\n \"0.73646206\",\n \"0.7337151\",\n \"0.733522\",\n \"0.73204684\",\n \"0.7319344\",\n \"0.7315561\",\n \"0.7312886\",\n \"0.72968775\",\n \"0.7276211\",\n \"0.7274837\",\n \"0.72666043\",\n \"0.72538304\",\n \"0.72514015\",\n \"0.72259086\",\n \"0.72171575\",\n \"0.7209841\",\n \"0.72038347\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203337\",\n \"0.7203047\",\n \"0.7203047\",\n \"0.7188015\",\n \"0.71835506\",\n \"0.7174273\",\n \"0.7171283\",\n \"0.71695065\",\n \"0.7169298\",\n \"0.7150135\",\n \"0.7144315\",\n \"0.71131754\",\n \"0.7108381\",\n \"0.70906496\",\n \"0.7089287\",\n \"0.7087746\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.7068474\",\n \"0.70606685\",\n \"0.70528996\",\n \"0.7043591\",\n \"0.7036554\",\n \"0.70276695\",\n \"0.701519\",\n \"0.7012193\",\n \"0.70107424\",\n \"0.7001337\",\n \"0.70003504\",\n \"0.69914514\",\n \"0.6991162\",\n \"0.69862646\",\n \"0.6980836\",\n \"0.69771427\",\n \"0.6975864\",\n \"0.69592273\",\n \"0.6957208\",\n \"0.6956571\",\n \"0.69260556\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9479,"cells":{"query":{"kind":"string","value":"Makes a directory after checking whether it already exists."},"document":{"kind":"string","value":"def mkdir(directory, parents=True):\n path_dir = Path(directory)\n if not path_dir.exists():\n path_dir.mkdir(parents=parents)"},"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 make_dir(self):\n if not os.path.exists(self.d):\n try:\n os.mkdir(self.d)\n except OSError, e:\n if e.errno != 17:\n raise\n pass","def new_dir(the_dir):\n try:\n os.makedirs(the_dir)\n except OSError as e:\n if e.errno == errno.EEXIST:\n pass #not a problem if file exists","def make_directory(self):\n if not os.path.isdir(self.directory):\n os.mkdir(self.directory)","def make_dir(path):\n if os.path.exists(path):\n return False\n else:\n os.makedirs(path, exist_ok=True)\n return True","def MakeDir(path):\n if os.path.exists(path):\n return False\n else:\n os.makedirs(path)\n return True","def _makeDir(self):\n try:\n os.mkdir(self.dir)\n # log('created directory: %s\\n' % self.dir)\n except OSError, err:\n if err.errno != errno.EEXIST:\n raise","def make_dir(d):\n if not os.path.exists(d):\n os.makedirs(d)","def make_dir(d):\n if not os.path.exists(d):\n os.makedirs(d)","def make_dir_if_needed(dir) :\n\tif not exists(dir) :\n\t\tos.makedirs(dir)","def _ensure_directory(self, dirname):\n if not os.path.exists(dirname):\n os.makedirs(dirname)","def create_dir():\n if check_dir_exist():\n return False\n else:\n os.makedirs(path_structure)\n return True","def make_dir(path):\n try:\n os.mkdir(path)\n except OSError:\n pass","def createDir(directory):\n if not os.path.exists(directory):\n statusCreation = os.makedirs(directory)\n else:\n statusCreation = 2\n return statusCreation","def make_dir(dir_path):\n if os.path.isdir(dir_path) == False:\n os.mkdir(dir_path)","def make_dir(self, path):\n import os\n if not os.path.exists(path):\n os.makedirs(path)","def make_dir(path):\n try:\n os.mkdir(path)\n except OSError:\n pass","def make_dir(path):\n try:\n os.mkdir(path)\n except OSError:\n pass","def make_dir(path):\n try:\n os.mkdir(path)\n except OSError:\n pass","def make_dir(path):\n try:\n os.mkdir(path)\n except OSError:\n pass","def _ensure_dir(directory):\r\n try:\r\n os.makedirs(directory)\r\n except OSError as exc:\r\n if exc.errno == errno.EEXIST:\r\n pass\r\n else:\r\n raise","def make_directory(name: str):\n try:\n os.mkdir(name)\n except:\n pass","def make_dir(directory):\n try:\n os.makedirs(directory)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise","def ensureDirectory(dirname):\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n print '>>> made directory \"%s\"'%(dirname)\n if not os.path.exists(dirname):\n print '>>> failed to make directory \"%s\"'%(dirname)\n return dirname","def create_dir(newdir):\n try:\n os.makedirs(newdir)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(newdir):\n pass\n else:\n raise","def _ensure_dir(dir_name):\n if not os.path.exists(dir_name):\n os.makedirs(dir_name)","def mkDir(path):\n if not os.path.exists(path):\n try:\n os.makedirs(path)\n except OSError:\n # In a race between two threads, this thread may have lost,\n # in which case the directory will now exist. Otherwise this\n # is a real exception.\n if not os.path.exists(path):\n raise","def make_dir_if_needed(path):\n\n if not os.path.exists(path):\n os.makedirs(path)\n return path","def dirmaker(dirp):\n try:\n if not os.path.exists(dirp):\n os.makedirs(dirp)\n except:\n pass","def ensureDirectory(dirname):\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n print \">>> made directory \" + dirname\n return dirname","def make_dir(directory):\n try:\n os.makedirs(directory)\n except OSError as err:\n if err.errno != errno.EEXIST:\n raise","def mkdir(path):","def maybe_make_dir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def make_dir(path=None):\n\n if not os.path.exists(path):\n try:\n os.makedirs(path)\n except OSError:\n exit(\"\\nOSError: You can not use that directory!\\n\")","def MakeDir(self, dirname):\n if os.path.exists(dirname):\n return\n try:\n os.umask(UMASK_DIR)\n os.makedirs(dirname)\n except OSError:\n self.errors = True\n errstr = '\\nCould not create directory: %s ... ' % dirname\n self.LogErrors(errstr)\n raise OSError(errstr)\n os.umask(UMASK_FILE)","def _make_new_directory(self, *, file_path: Path, need_init: bool):\r\n\r\n if Path(file_path).exists():\r\n raise FileExistsError(f\"The directory at {file_path} already exists.\")\r\n\r\n Path(file_path).mkdir(parents=True)\r\n\r\n if need_init:\r\n\r\n Path(file_path / \"__init__.py\").touch()\r\n\r\n self._logger.info(\"The directory %s has been created.\", file_path)","def create_dir(_dir):\n if not os.path.exists(_dir):\n os.makedirs(_dir)","def safeMkDir(pth):\n try: os.mkdir(pth)\n except OSError: print 'directory %s already exists ?!'%pth","def create_dir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def create_dir(directory):\n if not os.path.exists(directory):\n os.makedirs(directory)","def create_dir(directory):\n if not os.path.exists(directory):\n os.makedirs(directory)","def make_dir(directory):\n if not os.path.exists(directory):\n # noinspection PyBroadException\n try:\n os.mkdir(directory)\n except OSError as ex:\n logger.warning(\"Failed to create directory %s: %s\", directory, ex)\n sys.exit()","def create_directory(dirname):\n\n if dirname and not os.path.exists(dirname):\n os.makedirs(dirname)","def makeDir(dir_path):\n if os.path.exists(dir_path): return\n dir_path = os.path.realpath(dir_path)\n dir_path = os.path.normpath(dir_path)\n if os.path.exists(os.path.dirname(dir_path)):\n os.mkdir(dir_path)\n else:\n makeDir(os.path.dirname(dir_path))\n os.mkdir(dir_path)","def CreateDirectory(dir):\n if not os.path.exists(dir):\n os.makedirs(dir, 0777)","def make_directory(directory):\n logger.info(\"Create directory %s\", directory)\n if not os.path.exists(directory):\n os.mkdir(directory)\n else:\n logger.warning(\"Cannot create directory %s. Directory already exists\", directory)","def create_directory(directory):\n try:\n os.stat(directory)\n except:\n os.mkdir(directory)\n return","def create_directory(directory):\n try:\n os.stat(directory)\n except:\n os.mkdir(directory)\n return","def create_directory(directory):\n try:\n os.stat(directory)\n except:\n os.mkdir(directory)\n return","def create_directory(directory):\n try:\n os.stat(directory)\n except:\n os.mkdir(directory)\n return","def create_directory(directory):\n try:\n os.stat(directory)\n except:\n os.mkdir(directory)\n return","def ensure_dir( dirName ):\r\n if not os.path.exists( dirName ):\r\n os.makedirs( dirName )","def create_dir(dir, v=1):\n if not os.path.exists(dir):\n os.makedirs(dir)\n if v:\n print(\"Created Directory : \", dir)\n return 1\n else:\n if v:\n print(\"Directory already existed : \", dir)\n return 0","def create_dir(dirname):\n if not os.path.exists(dirname):\n os.makedirs(dirname)","def makeDir(dirName):\n try:\n os.makedirs(dirName)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(dirName):\n ## The path already exists so we can safely ignore this exception\n pass\n else:\n ## If it failed for some other reason, we want to see what the\n ## error is still\n raise","def create_dir(dir_):\n try:\n os.makedirs(dir_)\n logger.debug(\"Creating directory %s\", dir_)\n except OSError as err:\n if err.errno != errno.EEXIST:\n raise","def make_new_dir(path):\n\n if(not(os.path.isdir(path))):\n os.makedirs(path)\n\n return path","def create_directory(path, name):\n new_path = os.path.join(path, name)\n if not os.path.isdir(new_path):\n subprocess.run(['mkdir', new_path])","def create_new_dir(path):\n logger.debug('Function Successful: % s',\n 'create_new_dir: create_new_dir successfully called from save_single_file_locally', extra=d)\n\n if not os.path.exists(path):\n logger.debug('Calling Function: % s',\n 'create_new_dir: create_new_dir calling makedirs', extra=d)\n os.makedirs(path)\n logger.debug('Function Successful: % s',\n 'create_new_dir: create_new_dir successfully called makedirs', extra=d)","def ensure_dir(directory):\n if not os.path.exists(directory):\n os.makedirs(directory)","def ensure_dir(directory):\n if not os.path.exists(directory):\n os.makedirs(directory)","def create_dir_if_necessary(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise","def makenewdir(newdir):\n \n try:\n os.makedirs(newdir)\n except OSError as e:\n if e.errno == 17:\n pass","def makenewdir(newdir):\n \n try:\n os.makedirs(newdir)\n except OSError as e:\n if e.errno == 17:\n pass","def make_target_dir(directory):\n logger = logging.getLogger()\n try:\n makedirs(directory)\n logger.debug('Created directory %s', directory)\n return True\n except OSError as err:\n if err.errno != errno.EEXIST:\n raise\n if exists(directory):\n if isdir(directory):\n logger.debug('Directory %s already exists', directory)\n else:\n logger.error('Tried to create directory %s, but it already exists and is not a directory', directory)\n return False","def create_dir(dir):\n if not os.path.exists(dir):\n os.makedirs(dir)","def create_dir(dir):\n if not os.path.exists(dir):\n os.makedirs(dir)","def create_dir(dir_path):\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)","def ifnotexistmkdir(directory):\n if not os.path.exists(directory):\n os.mkdir(directory)\n return Path(directory)","def mkdir(path):\n if not os.path.exists(path):\n os.mkdir(path)","def create_directory_if_needed(directory_name):\n if not os.path.isdir(directory_name):\n os.makedirs(directory_name)","def create_directory(dir_path):\r\n if not os.path.exists(dir_path):\r\n os.makedirs(dir_path, exist_ok=True)","def _ensure_dir_exists(self, directory):\n directory = directory.strip()\n if not Path(directory).exists():\n os.mkdir(directory)","def makeDir(path):\r\n\r\n try:\r\n os.makedirs(path)\r\n except OSError as exc:\r\n if exc.errno == errno.EEXIST and os.path.isdir(path):\r\n pass\r\n else:\r\n raise","def ensuredir(dirname,verb=0):\n if not dirname:\n return \"\"\n if not os.path.exists(dirname):\n if verb>=1:\n print(\">>> Creating directory %s...\"%(dirname))\n os.makedirs(dirname)\n if not os.path.exists(dirname):\n print(\">>> Failed to make directory %s...\"%(dirname))\n return dirname","def create_directory():\r\n\r\n # Create directory for all lyrics\r\n try:\r\n os.mkdir(markovDir)\r\n except FileExistsError:\r\n pass","def mkdir(path):\n\tif not Path(path).exists():\n\t\tPath(path).mkdir(parents=True, exist_ok=True)","def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\n if os.path.isdir(pathToDir) and isCleanIfExists:\n shutil.rmtree(pathToDir)\n if not os.path.isdir(pathToDir):\n os.makedirs(pathToDir)","def Create_my_dir(new_path): #Create paths (windows os)\r\n if not os.path.exists(new_path):\r\n os.makedirs(new_path);","def create_or_clean_directory(dir):\n\tif not os.path.exists(dir):\n\t\tprint(\"The path \\\"\" + dir + \"\\\" does not exist\")\n\t\tprint(\"creating directory \\\"\" + dir + \"\\\"\")\n\t\tos.makedirs(dir)\n\telse: #Directory exists, but we want to clean it before use\n\t\tprint(dir + \" already exists. Cleaning before use...\")\n\t\tshutil.rmtree(dir)\n\t\tos.makedirs(dir)","def create_directory(path):\n try:\n os.makedirs(path) # pylint: disable=no-member\n except OSError as ex:\n if ex.errno != errno.EEXIST:\n raise","def create_dir(newdir):\n if not os.path.isdir(newdir):\n try:\n os.makedirs(newdir)\n print(newdir)\n except IOError:\n print(\"cannot create %s directoy\" % newdir)\n return 0","def makePath(path):\n\n with withFileLock(\"creating directory %s\" % path):\n if not os.path.isdir(path):\n os.makedirs(path)","def check_create_dir(directory):\n if not os.path.isdir(directory):\n if os.path.isfile(directory):\n raise RuntimeError(\"Cannot create directory %s, already \"\n \"exists as a file object\" % directory)\n os.makedirs(directory)\n log.debug(\"Making dir %s\" % directory)","def mkdir(dirname):\n try:\n os.mkdir(dirname)\n except Exception:\n pass","def mkdir(dir):\n\tif not os.path.exists(dir):\n\t\tos.makedirs(dir)","def makedirectory(path):\n\n exist_ok = True\n if not exist_ok and os.path.isdir(path):\n with contextlib.suppress(OSError):\n Path.mkdir(path, parents=True)","def dirChecking(dir):\n if not os.path.exists(dir):\n os.mkdir(dir)","def ensure_dir(d):\n\n if not os.path.exists(d):\n os.makedirs(d, exist_ok=True)\n\n return","def mkdir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def mkdir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def mkdir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def mkdir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def createDirectory(directory=DIRECTORY):\n if not os.path.exists(directory):\n os.mkdir(directory)","def create_dir(dir_path):\n\n if not path.exists(dir_path):\n log('Creating directory: {0}'.format(dir_path))\n run(sh.mkdir, dir_path, p=True)","def create_directory(directory=DIRECTORY):\n if not os.path.exists(directory):\n os.mkdir(directory)","def create_dir(directory):\n if not os.path.isdir(directory):\n os.makedirs(directory)","def _create_dir(filename):\n head = os.path.dirname(filename)\n if head != '' and not os.path.isdir(head):\n os.makedirs(head)","def prepare_dir(path, empty=False):\n\n def create_dir(path):\n \"\"\"\n Creates a directory\n :param path: string\n :return: nothing\n \"\"\"\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n\n if not os.path.exists(path):\n create_dir(path)","def mkdir(path):\n try: \n os.mkdir(path)\n except OSError:\n if not os.path.isdir(path):\n raise","def mkdir(directory):\n\n if os.path.exists(directory):\n if os.path.isfile(directory):\n message = \"Unable to created directory '%s': A file with that name already exists\"\n raise PyBuilderException(message, directory)\n return\n os.makedirs(directory)","def ensure_dir(dirName):\n if not os.path.exists(dirName):\n os.makedirs(dirName)"],"string":"[\n \"def make_dir(self):\\n if not os.path.exists(self.d):\\n try:\\n os.mkdir(self.d)\\n except OSError, e:\\n if e.errno != 17:\\n raise\\n pass\",\n \"def new_dir(the_dir):\\n try:\\n os.makedirs(the_dir)\\n except OSError as e:\\n if e.errno == errno.EEXIST:\\n pass #not a problem if file exists\",\n \"def make_directory(self):\\n if not os.path.isdir(self.directory):\\n os.mkdir(self.directory)\",\n \"def make_dir(path):\\n if os.path.exists(path):\\n return False\\n else:\\n os.makedirs(path, exist_ok=True)\\n return True\",\n \"def MakeDir(path):\\n if os.path.exists(path):\\n return False\\n else:\\n os.makedirs(path)\\n return True\",\n \"def _makeDir(self):\\n try:\\n os.mkdir(self.dir)\\n # log('created directory: %s\\\\n' % self.dir)\\n except OSError, err:\\n if err.errno != errno.EEXIST:\\n raise\",\n \"def make_dir(d):\\n if not os.path.exists(d):\\n os.makedirs(d)\",\n \"def make_dir(d):\\n if not os.path.exists(d):\\n os.makedirs(d)\",\n \"def make_dir_if_needed(dir) :\\n\\tif not exists(dir) :\\n\\t\\tos.makedirs(dir)\",\n \"def _ensure_directory(self, dirname):\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\",\n \"def create_dir():\\n if check_dir_exist():\\n return False\\n else:\\n os.makedirs(path_structure)\\n return True\",\n \"def make_dir(path):\\n try:\\n os.mkdir(path)\\n except OSError:\\n pass\",\n \"def createDir(directory):\\n if not os.path.exists(directory):\\n statusCreation = os.makedirs(directory)\\n else:\\n statusCreation = 2\\n return statusCreation\",\n \"def make_dir(dir_path):\\n if os.path.isdir(dir_path) == False:\\n os.mkdir(dir_path)\",\n \"def make_dir(self, path):\\n import os\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def make_dir(path):\\n try:\\n os.mkdir(path)\\n except OSError:\\n pass\",\n \"def make_dir(path):\\n try:\\n os.mkdir(path)\\n except OSError:\\n pass\",\n \"def make_dir(path):\\n try:\\n os.mkdir(path)\\n except OSError:\\n pass\",\n \"def make_dir(path):\\n try:\\n os.mkdir(path)\\n except OSError:\\n pass\",\n \"def _ensure_dir(directory):\\r\\n try:\\r\\n os.makedirs(directory)\\r\\n except OSError as exc:\\r\\n if exc.errno == errno.EEXIST:\\r\\n pass\\r\\n else:\\r\\n raise\",\n \"def make_directory(name: str):\\n try:\\n os.mkdir(name)\\n except:\\n pass\",\n \"def make_dir(directory):\\n try:\\n os.makedirs(directory)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n raise\",\n \"def ensureDirectory(dirname):\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\\n print '>>> made directory \\\"%s\\\"'%(dirname)\\n if not os.path.exists(dirname):\\n print '>>> failed to make directory \\\"%s\\\"'%(dirname)\\n return dirname\",\n \"def create_dir(newdir):\\n try:\\n os.makedirs(newdir)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(newdir):\\n pass\\n else:\\n raise\",\n \"def _ensure_dir(dir_name):\\n if not os.path.exists(dir_name):\\n os.makedirs(dir_name)\",\n \"def mkDir(path):\\n if not os.path.exists(path):\\n try:\\n os.makedirs(path)\\n except OSError:\\n # In a race between two threads, this thread may have lost,\\n # in which case the directory will now exist. Otherwise this\\n # is a real exception.\\n if not os.path.exists(path):\\n raise\",\n \"def make_dir_if_needed(path):\\n\\n if not os.path.exists(path):\\n os.makedirs(path)\\n return path\",\n \"def dirmaker(dirp):\\n try:\\n if not os.path.exists(dirp):\\n os.makedirs(dirp)\\n except:\\n pass\",\n \"def ensureDirectory(dirname):\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\\n print \\\">>> made directory \\\" + dirname\\n return dirname\",\n \"def make_dir(directory):\\n try:\\n os.makedirs(directory)\\n except OSError as err:\\n if err.errno != errno.EEXIST:\\n raise\",\n \"def mkdir(path):\",\n \"def maybe_make_dir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def make_dir(path=None):\\n\\n if not os.path.exists(path):\\n try:\\n os.makedirs(path)\\n except OSError:\\n exit(\\\"\\\\nOSError: You can not use that directory!\\\\n\\\")\",\n \"def MakeDir(self, dirname):\\n if os.path.exists(dirname):\\n return\\n try:\\n os.umask(UMASK_DIR)\\n os.makedirs(dirname)\\n except OSError:\\n self.errors = True\\n errstr = '\\\\nCould not create directory: %s ... ' % dirname\\n self.LogErrors(errstr)\\n raise OSError(errstr)\\n os.umask(UMASK_FILE)\",\n \"def _make_new_directory(self, *, file_path: Path, need_init: bool):\\r\\n\\r\\n if Path(file_path).exists():\\r\\n raise FileExistsError(f\\\"The directory at {file_path} already exists.\\\")\\r\\n\\r\\n Path(file_path).mkdir(parents=True)\\r\\n\\r\\n if need_init:\\r\\n\\r\\n Path(file_path / \\\"__init__.py\\\").touch()\\r\\n\\r\\n self._logger.info(\\\"The directory %s has been created.\\\", file_path)\",\n \"def create_dir(_dir):\\n if not os.path.exists(_dir):\\n os.makedirs(_dir)\",\n \"def safeMkDir(pth):\\n try: os.mkdir(pth)\\n except OSError: print 'directory %s already exists ?!'%pth\",\n \"def create_dir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def create_dir(directory):\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def create_dir(directory):\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def make_dir(directory):\\n if not os.path.exists(directory):\\n # noinspection PyBroadException\\n try:\\n os.mkdir(directory)\\n except OSError as ex:\\n logger.warning(\\\"Failed to create directory %s: %s\\\", directory, ex)\\n sys.exit()\",\n \"def create_directory(dirname):\\n\\n if dirname and not os.path.exists(dirname):\\n os.makedirs(dirname)\",\n \"def makeDir(dir_path):\\n if os.path.exists(dir_path): return\\n dir_path = os.path.realpath(dir_path)\\n dir_path = os.path.normpath(dir_path)\\n if os.path.exists(os.path.dirname(dir_path)):\\n os.mkdir(dir_path)\\n else:\\n makeDir(os.path.dirname(dir_path))\\n os.mkdir(dir_path)\",\n \"def CreateDirectory(dir):\\n if not os.path.exists(dir):\\n os.makedirs(dir, 0777)\",\n \"def make_directory(directory):\\n logger.info(\\\"Create directory %s\\\", directory)\\n if not os.path.exists(directory):\\n os.mkdir(directory)\\n else:\\n logger.warning(\\\"Cannot create directory %s. Directory already exists\\\", directory)\",\n \"def create_directory(directory):\\n try:\\n os.stat(directory)\\n except:\\n os.mkdir(directory)\\n return\",\n \"def create_directory(directory):\\n try:\\n os.stat(directory)\\n except:\\n os.mkdir(directory)\\n return\",\n \"def create_directory(directory):\\n try:\\n os.stat(directory)\\n except:\\n os.mkdir(directory)\\n return\",\n \"def create_directory(directory):\\n try:\\n os.stat(directory)\\n except:\\n os.mkdir(directory)\\n return\",\n \"def create_directory(directory):\\n try:\\n os.stat(directory)\\n except:\\n os.mkdir(directory)\\n return\",\n \"def ensure_dir( dirName ):\\r\\n if not os.path.exists( dirName ):\\r\\n os.makedirs( dirName )\",\n \"def create_dir(dir, v=1):\\n if not os.path.exists(dir):\\n os.makedirs(dir)\\n if v:\\n print(\\\"Created Directory : \\\", dir)\\n return 1\\n else:\\n if v:\\n print(\\\"Directory already existed : \\\", dir)\\n return 0\",\n \"def create_dir(dirname):\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\",\n \"def makeDir(dirName):\\n try:\\n os.makedirs(dirName)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(dirName):\\n ## The path already exists so we can safely ignore this exception\\n pass\\n else:\\n ## If it failed for some other reason, we want to see what the\\n ## error is still\\n raise\",\n \"def create_dir(dir_):\\n try:\\n os.makedirs(dir_)\\n logger.debug(\\\"Creating directory %s\\\", dir_)\\n except OSError as err:\\n if err.errno != errno.EEXIST:\\n raise\",\n \"def make_new_dir(path):\\n\\n if(not(os.path.isdir(path))):\\n os.makedirs(path)\\n\\n return path\",\n \"def create_directory(path, name):\\n new_path = os.path.join(path, name)\\n if not os.path.isdir(new_path):\\n subprocess.run(['mkdir', new_path])\",\n \"def create_new_dir(path):\\n logger.debug('Function Successful: % s',\\n 'create_new_dir: create_new_dir successfully called from save_single_file_locally', extra=d)\\n\\n if not os.path.exists(path):\\n logger.debug('Calling Function: % s',\\n 'create_new_dir: create_new_dir calling makedirs', extra=d)\\n os.makedirs(path)\\n logger.debug('Function Successful: % s',\\n 'create_new_dir: create_new_dir successfully called makedirs', extra=d)\",\n \"def ensure_dir(directory):\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def ensure_dir(directory):\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def create_dir_if_necessary(path):\\n try:\\n os.makedirs(path)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n raise\",\n \"def makenewdir(newdir):\\n \\n try:\\n os.makedirs(newdir)\\n except OSError as e:\\n if e.errno == 17:\\n pass\",\n \"def makenewdir(newdir):\\n \\n try:\\n os.makedirs(newdir)\\n except OSError as e:\\n if e.errno == 17:\\n pass\",\n \"def make_target_dir(directory):\\n logger = logging.getLogger()\\n try:\\n makedirs(directory)\\n logger.debug('Created directory %s', directory)\\n return True\\n except OSError as err:\\n if err.errno != errno.EEXIST:\\n raise\\n if exists(directory):\\n if isdir(directory):\\n logger.debug('Directory %s already exists', directory)\\n else:\\n logger.error('Tried to create directory %s, but it already exists and is not a directory', directory)\\n return False\",\n \"def create_dir(dir):\\n if not os.path.exists(dir):\\n os.makedirs(dir)\",\n \"def create_dir(dir):\\n if not os.path.exists(dir):\\n os.makedirs(dir)\",\n \"def create_dir(dir_path):\\n if not os.path.exists(dir_path):\\n os.makedirs(dir_path)\",\n \"def ifnotexistmkdir(directory):\\n if not os.path.exists(directory):\\n os.mkdir(directory)\\n return Path(directory)\",\n \"def mkdir(path):\\n if not os.path.exists(path):\\n os.mkdir(path)\",\n \"def create_directory_if_needed(directory_name):\\n if not os.path.isdir(directory_name):\\n os.makedirs(directory_name)\",\n \"def create_directory(dir_path):\\r\\n if not os.path.exists(dir_path):\\r\\n os.makedirs(dir_path, exist_ok=True)\",\n \"def _ensure_dir_exists(self, directory):\\n directory = directory.strip()\\n if not Path(directory).exists():\\n os.mkdir(directory)\",\n \"def makeDir(path):\\r\\n\\r\\n try:\\r\\n os.makedirs(path)\\r\\n except OSError as exc:\\r\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\r\\n pass\\r\\n else:\\r\\n raise\",\n \"def ensuredir(dirname,verb=0):\\n if not dirname:\\n return \\\"\\\"\\n if not os.path.exists(dirname):\\n if verb>=1:\\n print(\\\">>> Creating directory %s...\\\"%(dirname))\\n os.makedirs(dirname)\\n if not os.path.exists(dirname):\\n print(\\\">>> Failed to make directory %s...\\\"%(dirname))\\n return dirname\",\n \"def create_directory():\\r\\n\\r\\n # Create directory for all lyrics\\r\\n try:\\r\\n os.mkdir(markovDir)\\r\\n except FileExistsError:\\r\\n pass\",\n \"def mkdir(path):\\n\\tif not Path(path).exists():\\n\\t\\tPath(path).mkdir(parents=True, exist_ok=True)\",\n \"def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\\n if os.path.isdir(pathToDir) and isCleanIfExists:\\n shutil.rmtree(pathToDir)\\n if not os.path.isdir(pathToDir):\\n os.makedirs(pathToDir)\",\n \"def Create_my_dir(new_path): #Create paths (windows os)\\r\\n if not os.path.exists(new_path):\\r\\n os.makedirs(new_path);\",\n \"def create_or_clean_directory(dir):\\n\\tif not os.path.exists(dir):\\n\\t\\tprint(\\\"The path \\\\\\\"\\\" + dir + \\\"\\\\\\\" does not exist\\\")\\n\\t\\tprint(\\\"creating directory \\\\\\\"\\\" + dir + \\\"\\\\\\\"\\\")\\n\\t\\tos.makedirs(dir)\\n\\telse: #Directory exists, but we want to clean it before use\\n\\t\\tprint(dir + \\\" already exists. Cleaning before use...\\\")\\n\\t\\tshutil.rmtree(dir)\\n\\t\\tos.makedirs(dir)\",\n \"def create_directory(path):\\n try:\\n os.makedirs(path) # pylint: disable=no-member\\n except OSError as ex:\\n if ex.errno != errno.EEXIST:\\n raise\",\n \"def create_dir(newdir):\\n if not os.path.isdir(newdir):\\n try:\\n os.makedirs(newdir)\\n print(newdir)\\n except IOError:\\n print(\\\"cannot create %s directoy\\\" % newdir)\\n return 0\",\n \"def makePath(path):\\n\\n with withFileLock(\\\"creating directory %s\\\" % path):\\n if not os.path.isdir(path):\\n os.makedirs(path)\",\n \"def check_create_dir(directory):\\n if not os.path.isdir(directory):\\n if os.path.isfile(directory):\\n raise RuntimeError(\\\"Cannot create directory %s, already \\\"\\n \\\"exists as a file object\\\" % directory)\\n os.makedirs(directory)\\n log.debug(\\\"Making dir %s\\\" % directory)\",\n \"def mkdir(dirname):\\n try:\\n os.mkdir(dirname)\\n except Exception:\\n pass\",\n \"def mkdir(dir):\\n\\tif not os.path.exists(dir):\\n\\t\\tos.makedirs(dir)\",\n \"def makedirectory(path):\\n\\n exist_ok = True\\n if not exist_ok and os.path.isdir(path):\\n with contextlib.suppress(OSError):\\n Path.mkdir(path, parents=True)\",\n \"def dirChecking(dir):\\n if not os.path.exists(dir):\\n os.mkdir(dir)\",\n \"def ensure_dir(d):\\n\\n if not os.path.exists(d):\\n os.makedirs(d, exist_ok=True)\\n\\n return\",\n \"def mkdir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def mkdir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def mkdir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def mkdir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def createDirectory(directory=DIRECTORY):\\n if not os.path.exists(directory):\\n os.mkdir(directory)\",\n \"def create_dir(dir_path):\\n\\n if not path.exists(dir_path):\\n log('Creating directory: {0}'.format(dir_path))\\n run(sh.mkdir, dir_path, p=True)\",\n \"def create_directory(directory=DIRECTORY):\\n if not os.path.exists(directory):\\n os.mkdir(directory)\",\n \"def create_dir(directory):\\n if not os.path.isdir(directory):\\n os.makedirs(directory)\",\n \"def _create_dir(filename):\\n head = os.path.dirname(filename)\\n if head != '' and not os.path.isdir(head):\\n os.makedirs(head)\",\n \"def prepare_dir(path, empty=False):\\n\\n def create_dir(path):\\n \\\"\\\"\\\"\\n Creates a directory\\n :param path: string\\n :return: nothing\\n \\\"\\\"\\\"\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno != errno.EEXIST:\\n raise\\n\\n if not os.path.exists(path):\\n create_dir(path)\",\n \"def mkdir(path):\\n try: \\n os.mkdir(path)\\n except OSError:\\n if not os.path.isdir(path):\\n raise\",\n \"def mkdir(directory):\\n\\n if os.path.exists(directory):\\n if os.path.isfile(directory):\\n message = \\\"Unable to created directory '%s': A file with that name already exists\\\"\\n raise PyBuilderException(message, directory)\\n return\\n os.makedirs(directory)\",\n \"def ensure_dir(dirName):\\n if not os.path.exists(dirName):\\n os.makedirs(dirName)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83006763","0.81420314","0.80905235","0.7991284","0.7971449","0.7967864","0.79364747","0.79364747","0.7920723","0.7886012","0.78693926","0.78422606","0.7834246","0.7830855","0.78147686","0.7812152","0.7812152","0.7812152","0.7812152","0.78007835","0.7798517","0.77750313","0.7773203","0.77679306","0.7757129","0.7753274","0.7740904","0.77204484","0.77196085","0.77184045","0.7714093","0.771128","0.7694669","0.7657414","0.76536965","0.76394075","0.7637583","0.7628877","0.76226974","0.76226974","0.761024","0.7609249","0.76006514","0.75996166","0.7582793","0.7579691","0.7579691","0.7579691","0.7579691","0.7579691","0.75667703","0.7563078","0.7557868","0.7556979","0.7551858","0.7551688","0.755043","0.75427186","0.75387555","0.75387555","0.7535684","0.75338286","0.75338286","0.753279","0.7532706","0.7532706","0.7530656","0.7525822","0.7521199","0.7514264","0.75138414","0.75134814","0.7513298","0.7513202","0.75081366","0.7506655","0.7501053","0.74963474","0.74943215","0.7492975","0.74798036","0.7476549","0.7471385","0.74639505","0.74583614","0.7454414","0.74538946","0.74529696","0.7448963","0.7448963","0.7448963","0.7448963","0.7441633","0.74401623","0.74381506","0.7431186","0.7415761","0.7415439","0.7412515","0.7411452","0.74114126"],"string":"[\n \"0.83006763\",\n \"0.81420314\",\n \"0.80905235\",\n \"0.7991284\",\n \"0.7971449\",\n \"0.7967864\",\n \"0.79364747\",\n \"0.79364747\",\n \"0.7920723\",\n \"0.7886012\",\n \"0.78693926\",\n \"0.78422606\",\n \"0.7834246\",\n \"0.7830855\",\n \"0.78147686\",\n \"0.7812152\",\n \"0.7812152\",\n \"0.7812152\",\n \"0.7812152\",\n \"0.78007835\",\n \"0.7798517\",\n \"0.77750313\",\n \"0.7773203\",\n \"0.77679306\",\n \"0.7757129\",\n \"0.7753274\",\n \"0.7740904\",\n \"0.77204484\",\n \"0.77196085\",\n \"0.77184045\",\n \"0.7714093\",\n \"0.771128\",\n \"0.7694669\",\n \"0.7657414\",\n \"0.76536965\",\n \"0.76394075\",\n \"0.7637583\",\n \"0.7628877\",\n \"0.76226974\",\n \"0.76226974\",\n \"0.761024\",\n \"0.7609249\",\n \"0.76006514\",\n \"0.75996166\",\n \"0.7582793\",\n \"0.7579691\",\n \"0.7579691\",\n \"0.7579691\",\n \"0.7579691\",\n \"0.7579691\",\n \"0.75667703\",\n \"0.7563078\",\n \"0.7557868\",\n \"0.7556979\",\n \"0.7551858\",\n \"0.7551688\",\n \"0.755043\",\n \"0.75427186\",\n \"0.75387555\",\n \"0.75387555\",\n \"0.7535684\",\n \"0.75338286\",\n \"0.75338286\",\n \"0.753279\",\n \"0.7532706\",\n \"0.7532706\",\n \"0.7530656\",\n \"0.7525822\",\n \"0.7521199\",\n \"0.7514264\",\n \"0.75138414\",\n \"0.75134814\",\n \"0.7513298\",\n \"0.7513202\",\n \"0.75081366\",\n \"0.7506655\",\n \"0.7501053\",\n \"0.74963474\",\n \"0.74943215\",\n \"0.7492975\",\n \"0.74798036\",\n \"0.7476549\",\n \"0.7471385\",\n \"0.74639505\",\n \"0.74583614\",\n \"0.7454414\",\n \"0.74538946\",\n \"0.74529696\",\n \"0.7448963\",\n \"0.7448963\",\n \"0.7448963\",\n \"0.7448963\",\n \"0.7441633\",\n \"0.74401623\",\n \"0.74381506\",\n \"0.7431186\",\n \"0.7415761\",\n \"0.7415439\",\n \"0.7412515\",\n \"0.7411452\",\n \"0.74114126\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9480,"cells":{"query":{"kind":"string","value":"Removes an empty directory after checking whether it already exists."},"document":{"kind":"string","value":"def rmdir(directory, recursive=False):\n path_dir = Path(directory)\n if not path_dir.exists():\n return\n if recursive:\n shutil.rmtree(path_dir)\n else:\n if len(list(path_dir.iterdir())) == 0:\n path_dir.rmdir()\n else:\n raise ValueError(\n \"Cannot remove directory '{}' as it is not empty: consider removing it recursively\".format(path_dir))"},"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 remove_empty_path(self, empty):\n while True:\n if not os.path.isdir(empty):\n\n # Directory does not exist\n return\n\n if os.listdir(empty):\n # Directory is not empty\n return\n\n try:\n os.rmdir(empty)\n except OSError as e:\n raise TreeError('Error removing empty directory {}: {}'.format(empty, e))\n except IOError as e:\n raise TreeError('Error removing empty directory {}: {}'.format(empty, e))\n\n # Try to remove parent empty directory\n empty = os.path.dirname(empty)","def emptydir(directory):\n for path in os.listdir(directory):\n path = os.path.join(directory, path)\n if os.path.isfile(path):\n os.unlink(path)\n else:\n shutil.rmtree(path)","def _empty_dir(dir_: _P) -> _P:\n shutil.rmtree(dir_, ignore_errors=True)\n os.makedirs(dir_)\n return dir_","def rmEmptyDir(path):\n try:\n os.rmdir(path)\n except OSError as exc:\n return False\n return True","def reset_directory(path=None):\n import shutil\n isexists = os.path.exists(path)\n if isexists:\n shutil.rmtree(path)\n os.makedirs(path)","def _clean_directory(path):\n\n if os.path.exists(path):\n shutil.rmtree(os.path.join(path))\n os.mkdir(path)","def clear_directory(self, directory):\n if self.context.is_directory(directory):\n logger.verbose(\"Cleaning up existing directory (%s)..\", directory)\n self.context.execute('rm', '-fr', directory)\n logger.verbose(\"Creating directory (%s)..\", directory)\n self.context.execute('mkdir', '-p', directory)","def rmdir_empty(f):\n if not f.is_dir():\n return 0\n removable = True\n result = 0\n for i in f.iterdir():\n if i.is_dir():\n result += rmdir_empty(i)\n removable = removable and not i.exists()\n else:\n removable = removable and (i.name == '.DS_Store')\n if removable:\n items = list(f.iterdir())\n assert not items or items[0].name == '.DS_Store'\n print(f)\n shutil.rmtree(f)\n result += 1\n\n return result","def clear_or_create_directory(dir_name):\n shutil.rmtree(dir_name, ignore_errors=True)\n cntr = 0\n while True:\n try:\n os.makedirs(dir_name, exist_ok=True)\n return\n except OSError:\n if cntr < 10:\n # some windows bug?\n cntr += 1\n from time import sleep\n sleep(0.1 * cntr)\n else:\n raise","def remove_empty_dir(self, dir_folder, api):\n api = utils.cleanCO_API(api)\n dir_folder = join(dir_folder, api)\n if isdir(dir_folder):\n if os.listdir(dir_folder) == []:\n try:\n os.rmdir(dir_folder)\n except:\n pass","def clear_directory(path: str) -> None:\n if os.path.exists(path):\n print(f\"{COLOR['boldFont']}{COLOR['red']}[Warning]: remove directory: {path}{COLOR['none']}\")\n key = input(\"Do you want to continue? [Y/N]: \")\n if key.upper() == 'Y':\n shutil.rmtree(path)\n else:\n sys.exit(0)\n os.makedirs(path)","def make_empty_dir(d):\n\n if os.path.exists(d):\n shutil.rmtree(d)\n os.makedirs(d, exist_ok=True)\n else:\n os.makedirs(d, exist_ok=True)\n\n return","def remove_and_create_dir(path):\n dir = os.path.dirname(path)\n print('attempting to delete ', dir, ' path ', path)\n if os.path.exists(path):\n os.system(\"rm -rf \" + path)\n os.system(\"mkdir -p \" + path)","def delete_empty_dirs(src):\n if not os.path.isdir(src):\n return False\n\n if all ([delete_empty_dirs(os.path.join(src, file)) for file in os.listdir(src)]):\n log.info(\"Removing empty dir: (%s)\", src)\n os.rmdir(src)\n return True\n\n return False","def _clear_dir(dir_name):\n if os.path.isdir(dir_name):\n shutil.rmtree(dir_name)","def mkdir_clean(dir_path: str):\n if os.path.exists(dir_path):\n shutil.rmtree(dir_path)\n os.mkdir(dir_path)","def remove_dir(path):\n if os.path.exists(path):\n shutil.rmtree(path)","def rm_empty_folders(self, bottom: str):\n if not os.listdir(bottom):\n if not log.ask_yesno(\"delete empty folder '{}'?\".format(bottom), default='y'):\n return\n log.debug('deleting empty folder: {}'.format(bottom))\n os.rmdir(bottom)\n self.rm_empty_folders(os.path.split(bottom)[0])","def reset_directory(directory):\n if os.path.isdir(directory): shutil.rmtree(directory)\n if not os.path.isdir(directory): os.makedirs(directory)","def clean_directory():\n if os.path.exists('data'):\n shutil.rmtree('data')\n os.makedirs('data')\n\n if os.path.exists('returns'):\n shutil.rmtree('returns')\n os.makedirs('returns')","def clean_folder(path):\n if not os.path.exists(path):\n os.makedirs(path)\n else:\n shutil.rmtree(path)\n os.makedirs(path)","def create_empty_dir(dir_path):\n if os.path.isdir(dir_path):\n shutil.rmtree(dir_path)\n\n os.mkdir(dir_path)\n if not os.path.isdir(dir_path):\n raise OSError()","def cleanup_dir(dirname, removeRoot=False):\n\n if not os.path.isdir(dirname):\n return\n\n # remove empty subfolders\n files = os.listdir(dirname)\n if files > 0:\n for f in files:\n fullpath = os.path.join(dirname, f)\n if os.path.isdir(fullpath):\n cleanup_dir(fullpath, True)\n\n # if folder empty, delete it\n files = os.listdir(dirname)\n if files == 0 and removeRoot:\n try:\n os.rmdir(dirname)\n except:\n pass","def clean_dir(dir_: str):\n shutil.rmtree(dir_, ignore_errors=True)\n mkdir(dir_)","def remove_empty ( self ):\n with self._lock:\n for key in tuple ( self._subdirs.keys() ):\n if self._subdirs [key].check_empty():\n del self._subdirs [key]","def remove_output(path: str) -> None:\n try:\n Stat.remove(path)\n global remove_empty_directories # pylint: disable=invalid-name\n while remove_empty_directories.value:\n path = os.path.dirname(path)\n Stat.rmdir(path)\n Logger.file(f\"Remove the empty directory: {path}\")\n except OSError:\n pass","def create_or_clean_directory(dir):\n\tif not os.path.exists(dir):\n\t\tprint(\"The path \\\"\" + dir + \"\\\" does not exist\")\n\t\tprint(\"creating directory \\\"\" + dir + \"\\\"\")\n\t\tos.makedirs(dir)\n\telse: #Directory exists, but we want to clean it before use\n\t\tprint(dir + \" already exists. Cleaning before use...\")\n\t\tshutil.rmtree(dir)\n\t\tos.makedirs(dir)","def rmdir(path):","def clear_dir(directory):\n for f in os.listdir(directory):\n path = os.path.join(directory, f)\n try:\n if os.path.isfile(path):\n os.unlink(path)\n elif os.path.isdir(path):\n shutil.rmtree(path)\n except Exception as e:\n print(e)","def remove_dir(dir):\n if dir:\n if os.path.exists(dir):\n try:\n shutil.rmtree(dir)\n except Exception:\n pass","def rmdir(dir):\n print \"Trying to remove old\", dir, \"directory\"\n\n try:\n rmtree(dir)\n except OSError:\n print \"No directory\", dir, \". Skipping removal.\"\n pass\n finally:\n sleep(2)\n\n os.mkdir(dir)\n print 'Created new directory', dir\n sleep(2)","def test_remove_empty_dirs():\n config = get_config(\"delete.conf\")\n path = get_config_path(config)\n\n empty = path.joinpath(\"empty\")\n empty.mkdir(parents=True)\n\n assert empty.exists()\n console.pushbroom(config)\n assert not empty.exists()\n\n path.rmdir()","def clean_tmpdir(path):\n if os.path.exists(path) and \\\n os.path.isdir(path):\n rmtree(path)","def clear_dir(dir_path: str) -> None:\n files = os.listdir(dir_path)\n\n if len(files) != 0:\n while True:\n print(f\"\\nThe directory '{dir_path}' is not empty.\")\n answer = input(\n \"Do you wish to delete all files located here? (Y/N)\")\n\n if answer.upper() == 'Y':\n for f in files:\n os.remove(os.path.join(dir_path, f))\n break\n\n elif answer.upper() == 'N':\n raise DirectoryNotEmptyError()\n\n else:\n continue","def clear_dir(self, subdir=''):\n if not os.path.isdir(self.file_system.mount_point):\n raise exceptions.ValidationError(\"mount_point %s is not a directory\" % self.file_system.mount_point)\n if not os.path.isdir(self.full_path()):\n raise exceptions.ValidationError(\"project %s is not a directory\" % self.full_path())\n path = self.subdir(subdir)\n if not os.path.isdir(path):\n raise exceptions.ValidationError(\"%s is not a directory\" % path)\n for root, dirs, files in os.walk(path):\n for f in files:\n os.unlink(os.path.join(root, f))\n for d in dirs:\n shutil.rmtree(os.path.join(root, d))\n return True","def rmdir(path: str) -> None:\n Stat.forget(path)\n os.rmdir(path)","def rm_n_mkdir(dir_path):\n if os.path.isdir(dir_path):\n shutil.rmtree(dir_path)\n os.makedirs(dir_path)","def rmdir(dirname):\n if not os.path.exists(dirname):\n return\n if os.name == 'nt':\n check_output('rmdir {0!s} /S /Q'.format(dirname), shell=True)\n else:\n check_output(['rm', '-rf', dirname])","def removeDir(directory):\n if os.path.exists(directory):\n statusDeletion = shutil.rmtree(directory)\n else:\n statusDeletion = 2\n return statusDeletion","def RemoveDir(outdir):\n\n try:\n shutil.rmtree(outdir)\n except OSError:\n if not os.path.exists(outdir):\n return\n # On Windows this could be an issue with junctions, so try again with rmdir\n if sys.platform == 'win32':\n subprocess.check_call(['rmdir', '/S', '/Q', outdir], shell=True)","def ensure_build_dir(self):\n logging.debug('Ensuring build dir, {build_dir}, exists and is empty'.format(build_dir=self.build_dir))\n try:\n # raises OSError if path exists..\n os.makedirs(self.build_dir, exist_ok=False)\n except OSError:\n if not os.path.isdir(self.build_dir):\n raise\n\n # self.build_dir exists\n\n # recursively delete contents of build_dir, if exist\n # - let exceptions bubble up\n for file_ in os.listdir(self.build_dir):\n file_path = os.path.join(self.build_dir, file_)\n if os.path.isfile(file_path):\n os.unlink(file_path)\n elif os.path.isdir(file_path):\n shutil.rmtree(file_path)","def clean_up(self):\n directory = os.path.join(os.getcwd(), self.TMP_FOLDER)\n if os.path.exists(directory) and os.path.isdir(directory):\n shutil.rmtree(directory)","def _unlink(path):\n if os.path.isdir(path):\n os.rmdir(path)\n else:\n os.remove(path)","def clean_local_folder():\n\n if os.path.isdir(local_path):\n for file in os.listdir(local_path):\n os.remove(local_path + '/' + file)\n else:\n os.mkdir(local_path)","def _handle_dir_prune_empty(self, prunedir: str) -> None:\n # Walk the tree bottom-up so we can properly kill recursive empty dirs.\n for basename, dirnames, filenames in os.walk(prunedir, topdown=False):\n # It seems that child dirs we kill during the walk are still\n # listed when the parent dir is visited, so lets make sure\n # to only acknowledge still-existing ones.\n dirnames = [\n d for d in dirnames\n if os.path.exists(os.path.join(basename, d))\n ]\n if not dirnames and not filenames and basename != prunedir:\n os.rmdir(basename)","def _removeLockDir(self):\n try:\n os.rmdir(self.lockDir)\n except OSError, err:\n if err.errno != errno.ENOENT: \n raise","def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\n if os.path.isdir(pathToDir) and isCleanIfExists:\n shutil.rmtree(pathToDir)\n if not os.path.isdir(pathToDir):\n os.makedirs(pathToDir)","def deleteDir(self, path):\n\n # remove directory even if it has files\n shutil.rmtree(path, ignore_errors=True)","def prune_empty(self): # DirObj.prune_empty\n #print '# checking ' + self.pathname + ' for empties'\n if self.is_empty() and not self.deleted and self.parent == None:\n self.delete()\n #print '# TLD ' + self.pathname + ' is now empty: ' + str(self.is_empty())\n elif self.is_empty() and not self.deleted and self.parent != None and not self.parent.is_empty():\n self.delete()\n #print '# ' + self.pathname + ' is now empty: ' + str(self.is_empty())\n else:\n #print '# ' + self.pathname + ' is not empty: ' + str(self.is_empty())\n for dirname, dirEntry in self.subdirs.iteritems():\n dirEntry.prune_empty()","def test_no_remove_empty_dirs():\n config = get_config(\"no_remove_empty.conf\")\n path = get_config_path(config)\n\n empty = path.joinpath(\"empty\")\n empty.mkdir(parents=True)\n\n console.pushbroom(config)\n assert empty.exists()\n\n empty.rmdir()\n path.rmdir()","def remove_empty_dirs(root_dir):\n for root, dirs, files in os.walk(root_dir, topdown=False):\n for dirname in dirs:\n dirpath = os.path.join(root, dirname)\n if not os.listdir(dirpath): # check whether the dir is empty\n os.rmdir(dirpath)","def mkdir_if_missing(directory, delete_if_exist=False):\n\n if delete_if_exist and os.path.exists(directory): shutil.rmtree(directory)\n\n # check if not exist, then make\n if not os.path.exists(directory):\n os.makedirs(directory)","def mkdir_if_missing(directory, delete_if_exist=False):\n\n if delete_if_exist and os.path.exists(directory): shutil.rmtree(directory)\n\n # check if not exist, then make\n if not os.path.exists(directory):\n os.makedirs(directory)","def rmdir(self, path):\n self.log.debug(\"Local rmdir: %s\", path)\n shutil.rmtree(path)","def rmdir ( self, dirpath ):\n return","def clear_directory(directory: Union[str, Path]):\n for root, dirs, files in os.walk(directory, topdown=False):\n for file in files:\n os.remove(os.path.join(root, file))\n for dir in dirs:\n os.rmdir(os.path.join(root, dir))","def rmtree(self, directory):\n for entry in os.ilistdir(directory):\n is_dir = (entry[1] == 0x4000) # 0x4000 for directories and 0x8000 for regular files\n if is_dir:\n self.rmtree(directory + '/' + entry[0]) # Recurse into subdirectory\n else:\n os.remove(directory + '/' + entry[0]) # Remove this object\n os.rmdir(directory) # Remove the now empty directory.","def remove_dir(dir_path):\n try:\n shutil.rmtree(dir_path, ignore_errors=False)\n while os.path.isdir(dir_path):\n pass\n time.sleep(5)\n except Exception as e:\n warnings.warn(str(e))","def clean_scratch_dir(scratch_dir):\n if os.path.exists(scratch_dir):\n logging.info(\"Removing scratch dir %s \", scratch_dir)\n shutil.rmtree(scratch_dir)\n logging.info(\"Creating empty scratch dir %s \", scratch_dir)\n os.makedirs(scratch_dir)","def rmdir(self, path):\n os.rmdir(path)","def safe_rmtree(directory):\r\n if os.path.exists(directory):\r\n shutil.rmtree(directory, True)","def _ensure_dir_exists(self, directory):\n directory = directory.strip()\n if not Path(directory).exists():\n os.mkdir(directory)","def make_dir (path, empty=False):\n\n\n # check if google_cloud is set\n if not path[0:5] == 'gs://':\n\n # if already exists but needs to be empty, remove it first\n if isdir(path) and empty:\n shutil.rmtree(path)\n\n # do not check if directory exists, just try to make it; changed this\n # after racing condition occurred on the ilifu Slurm cluster when\n # reducing flatfields, where different tasks need to make the same\n # directory\n os.makedirs(path, exist_ok=True)\n\n\n return","def removeFolderIfExists(directory):\n try:\n shutil.rmtree(directory)\n except OSError as e: \n if e.errno != errno.ENOENT: # Continue if the error is \"no such file or directory\"\n raise # Re-raise the exception if a different error occured","def remove(self):\n if self.directory:\n os.rmdir(self.path)\n else:\n os.unlink(self.path)\n\n self.removed = True","def removeEmpties(self,name):\n empties = set()\n projectDir = dirs['installers'].join(name)\n for asDir,sDirs,sFiles in os.walk(projectDir.s):\n if not (sDirs or sFiles): empties.add(GPath(asDir))\n for empty in empties: empty.removedirs()\n projectDir.makedirs() #--In case it just got wiped out.","def forceRemoveDir(dirPath):\n if os.path.isdir(dirPath):\n shutil.rmtree(dirPath)","def clear_directory(directory):\n for i in os.listdir(directory):\n remove_items([os.path.join(directory, i)])","def rmtree(dirname):\n try:\n shutil.rmtree(dirname)\n except PermissionError:\n if sys.platform == \"win32\":\n subprocess.check_call([\"del\", \"/F/S/Q\", dirname], shell=True)\n else:\n raise","def rmtree(dirname):\n try:\n shutil.rmtree(dirname)\n except PermissionError:\n if sys.platform == \"win32\":\n subprocess.check_call([\"del\", \"/F/S/Q\", dirname], shell=True)\n else:\n raise","def rmdir(directory):\n directory = Path(directory)\n for item in directory.iterdir():\n if item.is_dir():\n rmdir(item)\n else:\n item.unlink()\n directory.rmdir()","def dir_empty(dir: str) -> bool:\n if dir_exists(dir) and len(list_files_recursively(dir)) > 0:\n return False\n return True","def clear_directory(self, directory):\n for root, dirs, files in os.walk(directory):\n for f in files:\n os.unlink(os.path.join(root, f))\n\n for d in dirs:\n shutil.rmtree(os.path.join(root, d))","def remove_dir_without_error(a_path):\r\n if not os.path.isdir(a_path):\r\n return\r\n for foo in os.listdir(a_path):\r\n abs_foo = os.path.join(a_path, foo)\r\n if os.path.isfile(abs_foo):\r\n try:\r\n os.remove(abs_foo)\r\n except Exception:\r\n continue\r\n else:\r\n remove_dir_without_error(abs_foo)\r\n try:\r\n shutil.rmtree(a_path)\r\n except Exception:\r\n return","def remove_dir_without_error(a_path):\r\n if not os.path.isdir(a_path):\r\n return\r\n for foo in os.listdir(a_path):\r\n abs_foo = os.path.join(a_path, foo)\r\n if os.path.isfile(abs_foo):\r\n try:\r\n os.remove(abs_foo)\r\n except Exception:\r\n continue\r\n else:\r\n remove_dir_without_error(abs_foo)\r\n try:\r\n shutil.rmtree(a_path)\r\n except Exception:\r\n return","def cleanup_tempdir(the_dir):\r\n if os.path.exists(the_dir):\r\n shutil.rmtree(the_dir)","def _dir_empty(path):\n try:\n next(os.scandir(str(path)))\n except StopIteration:\n return True\n return False","def empty_dir(value):\n return not os.listdir(value)","def rmdir(self, path: PathLike):","def remove_save_dir(dir_path):\n if os.path.exists(dir_path):\n shutil.rmtree(dir_path)","def clear_results_directory(self, name):\n if os.path.exists(name):\n shutil.rmtree(name)\n if name:\n os.mkdir(name)","def remove_dir(directory):\n if os.path.isdir(directory):\n try:\n shutil.rmtree(directory)\n except OSError as error:\n print \"Can't remove site dir {0}\\n Error: {1}\".format(directory, error.strerror)\n return False\n return True","def check_empty_dir(dir_path: str) -> None:\n if len(os.listdir(dir_path)) != 0:\n raise DirectoryNotEmptyError(f'\\n\\nMake sure \"{dir_path}\" is empty.\\n')","def delete_directory_contents(conn_obj, path, device=\"dut\"):\n command = \"rm -rf {}/*\".format(path.rstrip(\"/\"))\n if device == \"dut\":\n st.config(conn_obj, command)\n else:\n conn_obj.execute_command(conn_obj, command)\n return True","def prepare_dir(path, empty=False):\n\n def create_dir(path):\n \"\"\"\n Creates a directory\n :param path: string\n :return: nothing\n \"\"\"\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n\n if not os.path.exists(path):\n create_dir(path)","def addEmptyDir(self, path, baseToRemove=\"\", inZipRoot=None):\n\t\tinZipPath = os.path.relpath(path, baseToRemove)\n\t\tif inZipPath == \".\":\t# path == baseToRemove (but still root might be added\n\t\t\tinZipPath = \"\"\n\t\t\n\t\tif inZipRoot!=None:\n\t\t\tinZipPath = os.path.join(inZipRoot, inZipPath)\n\t\t\n\t\tif inZipPath == \"\":\t\t# nothing to add\n\t\t\treturn\n\n\t\tif self.verbose:\n\t\t\tprint \"Adding dir entry: \" + inZipPath\n\t\tzipInfo = zipfile.ZipInfo(os.path.join(inZipPath, ''))\n\t\tself.writestr(zipInfo, '')","def clean_dirs(output_dir):\n if os.path.exists(output_dir):\n shutil.rmtree(output_dir)\n os.makedirs(output_dir)","def remove_directory(tracking_id):\n complete_path = os.path.join(app.config['DRS_UPLOADS'], '{0}'.format(tracking_id))\n if os.path.isdir(complete_path):\n shutil.rmtree(complete_path, ignore_errors=False, onerror=None)\n return","def clearDirs(self):\n if self.listDirs.count() == 0:\n QtGui.QMessageBox.warning(self, \"Wait a second!\", \"Looks like you have nothing to clear.\")\n return\n # Confirmation Dialog\n sure = QtGui.QMessageBox.question(self, \"Confirm\", \"Are you sure?\",\n QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel, QtGui.QMessageBox.Cancel)\n if sure == QtGui.QMessageBox.Ok:\n self.listDirs.clear()\n self.listFiles.clear()","def clean_home_subdir(self):\n\n self.log.debug(\"Cleaning up %s...\" % self.home_subdir_local)\n try:\n for tree in os.listdir(self.home_subdir_local):\n self.log.debug(\"... removing %s subtree\" % tree)\n path = os.path.join(self.home_subdir_local, tree)\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n except OSError, err:\n self.log.error(\"Cleaning up intel dir %s failed: %s\" % (self.home_subdir_local, err))","def rmdir(folder_name: str) -> None:\n if not exist(folder_name):\n print(\"The folder does not exist\")\n return\n \n os.rmdir(folder_name)","def _remove_object_directory(directory):\n if not directory.exists():\n raise IOError(\"The directory '\" + str(directory) + \"' does not exist\")\n assert is_inside_exdir(directory)\n shutil.rmtree(directory)","def verify_directories_empty(self):\n if self.install_type == \"rpm\":\n return # For RPM install we don't want to clean anything\n\n instance_dir = \"frontend_%(service)s-%(instance)s\" % \\\n { \"service\": self.service_name(), \n \"instance\": self.glidein.instance_name(), }\n #-- directories to check ---\n dirs = {}\n dirs[\"logs........\"] = os.path.join(self.logs_dir(), instance_dir)\n dirs[\"install.....\"] = os.path.join(self.install_location(), instance_dir) \n dirs[\"config......\"] = self.config_dir()\n for subdir in [\"monitor\", \"stage\"]:\n dirs[\"web %s \" % subdir] = os.path.join(self.glidein.web_location(), subdir, instance_dir)\n #--- check them --\n for type in dirs.keys():\n if os.path.isdir(dirs[type]): \n if len(os.listdir(dirs[type])) == 0:\n os.rmdir(dirs[type])\n del dirs[type] # remove from dict\n else:\n del dirs[type] # it does not exist, remove from dict\n\n #--- if all are empty, return \n if len(dirs) == 0:\n time.sleep(3)\n return # all directories are empty\n\n #--- See if we can remove them --- \n common.logit(\"\"\"The following directories must be empty for the install to succeed: \"\"\")\n types = sorted(dirs.keys())\n for type in types:\n common.logit(\"\"\" %(type)s: %(dir)s\"\"\" % \\\n { \"type\" : type, \"dir\" : dirs[type] })\n common.ask_continue(\"... can we remove their contents\")\n for type in dirs.keys():\n common.remove_dir_contents(dirs[type])\n os.rmdir(dirs[type])\n time.sleep(3)\n return","def wipe_dir(fDic):\n if os.path.exists(fDic['topDir']):\n ans = input('The Directory Tree Structure for output already exists' +\n ' enter Y/N to erase directory.')\n if ans.upper() == 'Y':\n shutil.rmtree(fDic['topDir'])\n if not os.path.exists(fDic['topDir']) :\n # https://docs.python.org/2/library/os.html#files-and-directories\n os.makedirs(fDic['topDir'])\n os.makedirs(fDic['topDir'] + fDic['noHit'])","def shred_dir(directory):\n # Remove directory content\n for root, dirs, files in os.walk(directory, topdown=False):\n for fname in files:\n filepath = os_join(root, fname)\n LOG.info('Clean file %s' % fname)\n run_cmd('shred -f --remove %s' % filepath)\n for dname in dirs:\n dpath = os_join(root, dname)\n os.rmdir('%s' % dpath)\n # Remove the directory\n os.rmdir(directory)","def cleanOutputDir(output):\n if os.path.exists(output) and os.path.isdir(output):\n shutil.rmtree(output)","def delete_folder(self, path):\n if not path_exists(path, self._store_folder):\n raise NotFoundException(\"\")\n rmdir(path)","def drop_empty_folders(BaseFolder):\n\n for root, dirs, files in os.walk(BaseFolder, topdown=False):\n if not dirs and not files:\n os.rmdir(root)","def mkdir(self, directory):\n self.logger.info(f\"remove and mkdir {directory}\")\n self.conn.run(f\"rm -rf {directory}\", hide=True)\n self.conn.run(f\"mkdir -p {directory}\", hide=True)\n return directory","def cleanup(self):\n\n # check if the directory exists\n if not os.path.exists(self.path):\n return\n\n # check if the directory is a directory\n if not os.path.isdir(self.path):\n return\n\n # loop over content of directory and remove it\n for the_file in os.listdir(self.path):\n file_path = os.path.join(self.path, the_file)\n try:\n if os.path.isfile(file_path):\n os.unlink(file_path)\n elif os.path.isdir(file_path):\n shutil.rmtree(file_path)\n except Exception as e:\n pass","def clean_dist(dist_directory):\n\n # Remove the old folder.\n shutil.rmtree(dist_directory, ignore_errors=True)\n\n # Create a new one\n os.mkdir(dist_directory)"],"string":"[\n \"def remove_empty_path(self, empty):\\n while True:\\n if not os.path.isdir(empty):\\n\\n # Directory does not exist\\n return\\n\\n if os.listdir(empty):\\n # Directory is not empty\\n return\\n\\n try:\\n os.rmdir(empty)\\n except OSError as e:\\n raise TreeError('Error removing empty directory {}: {}'.format(empty, e))\\n except IOError as e:\\n raise TreeError('Error removing empty directory {}: {}'.format(empty, e))\\n\\n # Try to remove parent empty directory\\n empty = os.path.dirname(empty)\",\n \"def emptydir(directory):\\n for path in os.listdir(directory):\\n path = os.path.join(directory, path)\\n if os.path.isfile(path):\\n os.unlink(path)\\n else:\\n shutil.rmtree(path)\",\n \"def _empty_dir(dir_: _P) -> _P:\\n shutil.rmtree(dir_, ignore_errors=True)\\n os.makedirs(dir_)\\n return dir_\",\n \"def rmEmptyDir(path):\\n try:\\n os.rmdir(path)\\n except OSError as exc:\\n return False\\n return True\",\n \"def reset_directory(path=None):\\n import shutil\\n isexists = os.path.exists(path)\\n if isexists:\\n shutil.rmtree(path)\\n os.makedirs(path)\",\n \"def _clean_directory(path):\\n\\n if os.path.exists(path):\\n shutil.rmtree(os.path.join(path))\\n os.mkdir(path)\",\n \"def clear_directory(self, directory):\\n if self.context.is_directory(directory):\\n logger.verbose(\\\"Cleaning up existing directory (%s)..\\\", directory)\\n self.context.execute('rm', '-fr', directory)\\n logger.verbose(\\\"Creating directory (%s)..\\\", directory)\\n self.context.execute('mkdir', '-p', directory)\",\n \"def rmdir_empty(f):\\n if not f.is_dir():\\n return 0\\n removable = True\\n result = 0\\n for i in f.iterdir():\\n if i.is_dir():\\n result += rmdir_empty(i)\\n removable = removable and not i.exists()\\n else:\\n removable = removable and (i.name == '.DS_Store')\\n if removable:\\n items = list(f.iterdir())\\n assert not items or items[0].name == '.DS_Store'\\n print(f)\\n shutil.rmtree(f)\\n result += 1\\n\\n return result\",\n \"def clear_or_create_directory(dir_name):\\n shutil.rmtree(dir_name, ignore_errors=True)\\n cntr = 0\\n while True:\\n try:\\n os.makedirs(dir_name, exist_ok=True)\\n return\\n except OSError:\\n if cntr < 10:\\n # some windows bug?\\n cntr += 1\\n from time import sleep\\n sleep(0.1 * cntr)\\n else:\\n raise\",\n \"def remove_empty_dir(self, dir_folder, api):\\n api = utils.cleanCO_API(api)\\n dir_folder = join(dir_folder, api)\\n if isdir(dir_folder):\\n if os.listdir(dir_folder) == []:\\n try:\\n os.rmdir(dir_folder)\\n except:\\n pass\",\n \"def clear_directory(path: str) -> None:\\n if os.path.exists(path):\\n print(f\\\"{COLOR['boldFont']}{COLOR['red']}[Warning]: remove directory: {path}{COLOR['none']}\\\")\\n key = input(\\\"Do you want to continue? [Y/N]: \\\")\\n if key.upper() == 'Y':\\n shutil.rmtree(path)\\n else:\\n sys.exit(0)\\n os.makedirs(path)\",\n \"def make_empty_dir(d):\\n\\n if os.path.exists(d):\\n shutil.rmtree(d)\\n os.makedirs(d, exist_ok=True)\\n else:\\n os.makedirs(d, exist_ok=True)\\n\\n return\",\n \"def remove_and_create_dir(path):\\n dir = os.path.dirname(path)\\n print('attempting to delete ', dir, ' path ', path)\\n if os.path.exists(path):\\n os.system(\\\"rm -rf \\\" + path)\\n os.system(\\\"mkdir -p \\\" + path)\",\n \"def delete_empty_dirs(src):\\n if not os.path.isdir(src):\\n return False\\n\\n if all ([delete_empty_dirs(os.path.join(src, file)) for file in os.listdir(src)]):\\n log.info(\\\"Removing empty dir: (%s)\\\", src)\\n os.rmdir(src)\\n return True\\n\\n return False\",\n \"def _clear_dir(dir_name):\\n if os.path.isdir(dir_name):\\n shutil.rmtree(dir_name)\",\n \"def mkdir_clean(dir_path: str):\\n if os.path.exists(dir_path):\\n shutil.rmtree(dir_path)\\n os.mkdir(dir_path)\",\n \"def remove_dir(path):\\n if os.path.exists(path):\\n shutil.rmtree(path)\",\n \"def rm_empty_folders(self, bottom: str):\\n if not os.listdir(bottom):\\n if not log.ask_yesno(\\\"delete empty folder '{}'?\\\".format(bottom), default='y'):\\n return\\n log.debug('deleting empty folder: {}'.format(bottom))\\n os.rmdir(bottom)\\n self.rm_empty_folders(os.path.split(bottom)[0])\",\n \"def reset_directory(directory):\\n if os.path.isdir(directory): shutil.rmtree(directory)\\n if not os.path.isdir(directory): os.makedirs(directory)\",\n \"def clean_directory():\\n if os.path.exists('data'):\\n shutil.rmtree('data')\\n os.makedirs('data')\\n\\n if os.path.exists('returns'):\\n shutil.rmtree('returns')\\n os.makedirs('returns')\",\n \"def clean_folder(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\\n else:\\n shutil.rmtree(path)\\n os.makedirs(path)\",\n \"def create_empty_dir(dir_path):\\n if os.path.isdir(dir_path):\\n shutil.rmtree(dir_path)\\n\\n os.mkdir(dir_path)\\n if not os.path.isdir(dir_path):\\n raise OSError()\",\n \"def cleanup_dir(dirname, removeRoot=False):\\n\\n if not os.path.isdir(dirname):\\n return\\n\\n # remove empty subfolders\\n files = os.listdir(dirname)\\n if files > 0:\\n for f in files:\\n fullpath = os.path.join(dirname, f)\\n if os.path.isdir(fullpath):\\n cleanup_dir(fullpath, True)\\n\\n # if folder empty, delete it\\n files = os.listdir(dirname)\\n if files == 0 and removeRoot:\\n try:\\n os.rmdir(dirname)\\n except:\\n pass\",\n \"def clean_dir(dir_: str):\\n shutil.rmtree(dir_, ignore_errors=True)\\n mkdir(dir_)\",\n \"def remove_empty ( self ):\\n with self._lock:\\n for key in tuple ( self._subdirs.keys() ):\\n if self._subdirs [key].check_empty():\\n del self._subdirs [key]\",\n \"def remove_output(path: str) -> None:\\n try:\\n Stat.remove(path)\\n global remove_empty_directories # pylint: disable=invalid-name\\n while remove_empty_directories.value:\\n path = os.path.dirname(path)\\n Stat.rmdir(path)\\n Logger.file(f\\\"Remove the empty directory: {path}\\\")\\n except OSError:\\n pass\",\n \"def create_or_clean_directory(dir):\\n\\tif not os.path.exists(dir):\\n\\t\\tprint(\\\"The path \\\\\\\"\\\" + dir + \\\"\\\\\\\" does not exist\\\")\\n\\t\\tprint(\\\"creating directory \\\\\\\"\\\" + dir + \\\"\\\\\\\"\\\")\\n\\t\\tos.makedirs(dir)\\n\\telse: #Directory exists, but we want to clean it before use\\n\\t\\tprint(dir + \\\" already exists. Cleaning before use...\\\")\\n\\t\\tshutil.rmtree(dir)\\n\\t\\tos.makedirs(dir)\",\n \"def rmdir(path):\",\n \"def clear_dir(directory):\\n for f in os.listdir(directory):\\n path = os.path.join(directory, f)\\n try:\\n if os.path.isfile(path):\\n os.unlink(path)\\n elif os.path.isdir(path):\\n shutil.rmtree(path)\\n except Exception as e:\\n print(e)\",\n \"def remove_dir(dir):\\n if dir:\\n if os.path.exists(dir):\\n try:\\n shutil.rmtree(dir)\\n except Exception:\\n pass\",\n \"def rmdir(dir):\\n print \\\"Trying to remove old\\\", dir, \\\"directory\\\"\\n\\n try:\\n rmtree(dir)\\n except OSError:\\n print \\\"No directory\\\", dir, \\\". Skipping removal.\\\"\\n pass\\n finally:\\n sleep(2)\\n\\n os.mkdir(dir)\\n print 'Created new directory', dir\\n sleep(2)\",\n \"def test_remove_empty_dirs():\\n config = get_config(\\\"delete.conf\\\")\\n path = get_config_path(config)\\n\\n empty = path.joinpath(\\\"empty\\\")\\n empty.mkdir(parents=True)\\n\\n assert empty.exists()\\n console.pushbroom(config)\\n assert not empty.exists()\\n\\n path.rmdir()\",\n \"def clean_tmpdir(path):\\n if os.path.exists(path) and \\\\\\n os.path.isdir(path):\\n rmtree(path)\",\n \"def clear_dir(dir_path: str) -> None:\\n files = os.listdir(dir_path)\\n\\n if len(files) != 0:\\n while True:\\n print(f\\\"\\\\nThe directory '{dir_path}' is not empty.\\\")\\n answer = input(\\n \\\"Do you wish to delete all files located here? (Y/N)\\\")\\n\\n if answer.upper() == 'Y':\\n for f in files:\\n os.remove(os.path.join(dir_path, f))\\n break\\n\\n elif answer.upper() == 'N':\\n raise DirectoryNotEmptyError()\\n\\n else:\\n continue\",\n \"def clear_dir(self, subdir=''):\\n if not os.path.isdir(self.file_system.mount_point):\\n raise exceptions.ValidationError(\\\"mount_point %s is not a directory\\\" % self.file_system.mount_point)\\n if not os.path.isdir(self.full_path()):\\n raise exceptions.ValidationError(\\\"project %s is not a directory\\\" % self.full_path())\\n path = self.subdir(subdir)\\n if not os.path.isdir(path):\\n raise exceptions.ValidationError(\\\"%s is not a directory\\\" % path)\\n for root, dirs, files in os.walk(path):\\n for f in files:\\n os.unlink(os.path.join(root, f))\\n for d in dirs:\\n shutil.rmtree(os.path.join(root, d))\\n return True\",\n \"def rmdir(path: str) -> None:\\n Stat.forget(path)\\n os.rmdir(path)\",\n \"def rm_n_mkdir(dir_path):\\n if os.path.isdir(dir_path):\\n shutil.rmtree(dir_path)\\n os.makedirs(dir_path)\",\n \"def rmdir(dirname):\\n if not os.path.exists(dirname):\\n return\\n if os.name == 'nt':\\n check_output('rmdir {0!s} /S /Q'.format(dirname), shell=True)\\n else:\\n check_output(['rm', '-rf', dirname])\",\n \"def removeDir(directory):\\n if os.path.exists(directory):\\n statusDeletion = shutil.rmtree(directory)\\n else:\\n statusDeletion = 2\\n return statusDeletion\",\n \"def RemoveDir(outdir):\\n\\n try:\\n shutil.rmtree(outdir)\\n except OSError:\\n if not os.path.exists(outdir):\\n return\\n # On Windows this could be an issue with junctions, so try again with rmdir\\n if sys.platform == 'win32':\\n subprocess.check_call(['rmdir', '/S', '/Q', outdir], shell=True)\",\n \"def ensure_build_dir(self):\\n logging.debug('Ensuring build dir, {build_dir}, exists and is empty'.format(build_dir=self.build_dir))\\n try:\\n # raises OSError if path exists..\\n os.makedirs(self.build_dir, exist_ok=False)\\n except OSError:\\n if not os.path.isdir(self.build_dir):\\n raise\\n\\n # self.build_dir exists\\n\\n # recursively delete contents of build_dir, if exist\\n # - let exceptions bubble up\\n for file_ in os.listdir(self.build_dir):\\n file_path = os.path.join(self.build_dir, file_)\\n if os.path.isfile(file_path):\\n os.unlink(file_path)\\n elif os.path.isdir(file_path):\\n shutil.rmtree(file_path)\",\n \"def clean_up(self):\\n directory = os.path.join(os.getcwd(), self.TMP_FOLDER)\\n if os.path.exists(directory) and os.path.isdir(directory):\\n shutil.rmtree(directory)\",\n \"def _unlink(path):\\n if os.path.isdir(path):\\n os.rmdir(path)\\n else:\\n os.remove(path)\",\n \"def clean_local_folder():\\n\\n if os.path.isdir(local_path):\\n for file in os.listdir(local_path):\\n os.remove(local_path + '/' + file)\\n else:\\n os.mkdir(local_path)\",\n \"def _handle_dir_prune_empty(self, prunedir: str) -> None:\\n # Walk the tree bottom-up so we can properly kill recursive empty dirs.\\n for basename, dirnames, filenames in os.walk(prunedir, topdown=False):\\n # It seems that child dirs we kill during the walk are still\\n # listed when the parent dir is visited, so lets make sure\\n # to only acknowledge still-existing ones.\\n dirnames = [\\n d for d in dirnames\\n if os.path.exists(os.path.join(basename, d))\\n ]\\n if not dirnames and not filenames and basename != prunedir:\\n os.rmdir(basename)\",\n \"def _removeLockDir(self):\\n try:\\n os.rmdir(self.lockDir)\\n except OSError, err:\\n if err.errno != errno.ENOENT: \\n raise\",\n \"def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\\n if os.path.isdir(pathToDir) and isCleanIfExists:\\n shutil.rmtree(pathToDir)\\n if not os.path.isdir(pathToDir):\\n os.makedirs(pathToDir)\",\n \"def deleteDir(self, path):\\n\\n # remove directory even if it has files\\n shutil.rmtree(path, ignore_errors=True)\",\n \"def prune_empty(self): # DirObj.prune_empty\\n #print '# checking ' + self.pathname + ' for empties'\\n if self.is_empty() and not self.deleted and self.parent == None:\\n self.delete()\\n #print '# TLD ' + self.pathname + ' is now empty: ' + str(self.is_empty())\\n elif self.is_empty() and not self.deleted and self.parent != None and not self.parent.is_empty():\\n self.delete()\\n #print '# ' + self.pathname + ' is now empty: ' + str(self.is_empty())\\n else:\\n #print '# ' + self.pathname + ' is not empty: ' + str(self.is_empty())\\n for dirname, dirEntry in self.subdirs.iteritems():\\n dirEntry.prune_empty()\",\n \"def test_no_remove_empty_dirs():\\n config = get_config(\\\"no_remove_empty.conf\\\")\\n path = get_config_path(config)\\n\\n empty = path.joinpath(\\\"empty\\\")\\n empty.mkdir(parents=True)\\n\\n console.pushbroom(config)\\n assert empty.exists()\\n\\n empty.rmdir()\\n path.rmdir()\",\n \"def remove_empty_dirs(root_dir):\\n for root, dirs, files in os.walk(root_dir, topdown=False):\\n for dirname in dirs:\\n dirpath = os.path.join(root, dirname)\\n if not os.listdir(dirpath): # check whether the dir is empty\\n os.rmdir(dirpath)\",\n \"def mkdir_if_missing(directory, delete_if_exist=False):\\n\\n if delete_if_exist and os.path.exists(directory): shutil.rmtree(directory)\\n\\n # check if not exist, then make\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def mkdir_if_missing(directory, delete_if_exist=False):\\n\\n if delete_if_exist and os.path.exists(directory): shutil.rmtree(directory)\\n\\n # check if not exist, then make\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def rmdir(self, path):\\n self.log.debug(\\\"Local rmdir: %s\\\", path)\\n shutil.rmtree(path)\",\n \"def rmdir ( self, dirpath ):\\n return\",\n \"def clear_directory(directory: Union[str, Path]):\\n for root, dirs, files in os.walk(directory, topdown=False):\\n for file in files:\\n os.remove(os.path.join(root, file))\\n for dir in dirs:\\n os.rmdir(os.path.join(root, dir))\",\n \"def rmtree(self, directory):\\n for entry in os.ilistdir(directory):\\n is_dir = (entry[1] == 0x4000) # 0x4000 for directories and 0x8000 for regular files\\n if is_dir:\\n self.rmtree(directory + '/' + entry[0]) # Recurse into subdirectory\\n else:\\n os.remove(directory + '/' + entry[0]) # Remove this object\\n os.rmdir(directory) # Remove the now empty directory.\",\n \"def remove_dir(dir_path):\\n try:\\n shutil.rmtree(dir_path, ignore_errors=False)\\n while os.path.isdir(dir_path):\\n pass\\n time.sleep(5)\\n except Exception as e:\\n warnings.warn(str(e))\",\n \"def clean_scratch_dir(scratch_dir):\\n if os.path.exists(scratch_dir):\\n logging.info(\\\"Removing scratch dir %s \\\", scratch_dir)\\n shutil.rmtree(scratch_dir)\\n logging.info(\\\"Creating empty scratch dir %s \\\", scratch_dir)\\n os.makedirs(scratch_dir)\",\n \"def rmdir(self, path):\\n os.rmdir(path)\",\n \"def safe_rmtree(directory):\\r\\n if os.path.exists(directory):\\r\\n shutil.rmtree(directory, True)\",\n \"def _ensure_dir_exists(self, directory):\\n directory = directory.strip()\\n if not Path(directory).exists():\\n os.mkdir(directory)\",\n \"def make_dir (path, empty=False):\\n\\n\\n # check if google_cloud is set\\n if not path[0:5] == 'gs://':\\n\\n # if already exists but needs to be empty, remove it first\\n if isdir(path) and empty:\\n shutil.rmtree(path)\\n\\n # do not check if directory exists, just try to make it; changed this\\n # after racing condition occurred on the ilifu Slurm cluster when\\n # reducing flatfields, where different tasks need to make the same\\n # directory\\n os.makedirs(path, exist_ok=True)\\n\\n\\n return\",\n \"def removeFolderIfExists(directory):\\n try:\\n shutil.rmtree(directory)\\n except OSError as e: \\n if e.errno != errno.ENOENT: # Continue if the error is \\\"no such file or directory\\\"\\n raise # Re-raise the exception if a different error occured\",\n \"def remove(self):\\n if self.directory:\\n os.rmdir(self.path)\\n else:\\n os.unlink(self.path)\\n\\n self.removed = True\",\n \"def removeEmpties(self,name):\\n empties = set()\\n projectDir = dirs['installers'].join(name)\\n for asDir,sDirs,sFiles in os.walk(projectDir.s):\\n if not (sDirs or sFiles): empties.add(GPath(asDir))\\n for empty in empties: empty.removedirs()\\n projectDir.makedirs() #--In case it just got wiped out.\",\n \"def forceRemoveDir(dirPath):\\n if os.path.isdir(dirPath):\\n shutil.rmtree(dirPath)\",\n \"def clear_directory(directory):\\n for i in os.listdir(directory):\\n remove_items([os.path.join(directory, i)])\",\n \"def rmtree(dirname):\\n try:\\n shutil.rmtree(dirname)\\n except PermissionError:\\n if sys.platform == \\\"win32\\\":\\n subprocess.check_call([\\\"del\\\", \\\"/F/S/Q\\\", dirname], shell=True)\\n else:\\n raise\",\n \"def rmtree(dirname):\\n try:\\n shutil.rmtree(dirname)\\n except PermissionError:\\n if sys.platform == \\\"win32\\\":\\n subprocess.check_call([\\\"del\\\", \\\"/F/S/Q\\\", dirname], shell=True)\\n else:\\n raise\",\n \"def rmdir(directory):\\n directory = Path(directory)\\n for item in directory.iterdir():\\n if item.is_dir():\\n rmdir(item)\\n else:\\n item.unlink()\\n directory.rmdir()\",\n \"def dir_empty(dir: str) -> bool:\\n if dir_exists(dir) and len(list_files_recursively(dir)) > 0:\\n return False\\n return True\",\n \"def clear_directory(self, directory):\\n for root, dirs, files in os.walk(directory):\\n for f in files:\\n os.unlink(os.path.join(root, f))\\n\\n for d in dirs:\\n shutil.rmtree(os.path.join(root, d))\",\n \"def remove_dir_without_error(a_path):\\r\\n if not os.path.isdir(a_path):\\r\\n return\\r\\n for foo in os.listdir(a_path):\\r\\n abs_foo = os.path.join(a_path, foo)\\r\\n if os.path.isfile(abs_foo):\\r\\n try:\\r\\n os.remove(abs_foo)\\r\\n except Exception:\\r\\n continue\\r\\n else:\\r\\n remove_dir_without_error(abs_foo)\\r\\n try:\\r\\n shutil.rmtree(a_path)\\r\\n except Exception:\\r\\n return\",\n \"def remove_dir_without_error(a_path):\\r\\n if not os.path.isdir(a_path):\\r\\n return\\r\\n for foo in os.listdir(a_path):\\r\\n abs_foo = os.path.join(a_path, foo)\\r\\n if os.path.isfile(abs_foo):\\r\\n try:\\r\\n os.remove(abs_foo)\\r\\n except Exception:\\r\\n continue\\r\\n else:\\r\\n remove_dir_without_error(abs_foo)\\r\\n try:\\r\\n shutil.rmtree(a_path)\\r\\n except Exception:\\r\\n return\",\n \"def cleanup_tempdir(the_dir):\\r\\n if os.path.exists(the_dir):\\r\\n shutil.rmtree(the_dir)\",\n \"def _dir_empty(path):\\n try:\\n next(os.scandir(str(path)))\\n except StopIteration:\\n return True\\n return False\",\n \"def empty_dir(value):\\n return not os.listdir(value)\",\n \"def rmdir(self, path: PathLike):\",\n \"def remove_save_dir(dir_path):\\n if os.path.exists(dir_path):\\n shutil.rmtree(dir_path)\",\n \"def clear_results_directory(self, name):\\n if os.path.exists(name):\\n shutil.rmtree(name)\\n if name:\\n os.mkdir(name)\",\n \"def remove_dir(directory):\\n if os.path.isdir(directory):\\n try:\\n shutil.rmtree(directory)\\n except OSError as error:\\n print \\\"Can't remove site dir {0}\\\\n Error: {1}\\\".format(directory, error.strerror)\\n return False\\n return True\",\n \"def check_empty_dir(dir_path: str) -> None:\\n if len(os.listdir(dir_path)) != 0:\\n raise DirectoryNotEmptyError(f'\\\\n\\\\nMake sure \\\"{dir_path}\\\" is empty.\\\\n')\",\n \"def delete_directory_contents(conn_obj, path, device=\\\"dut\\\"):\\n command = \\\"rm -rf {}/*\\\".format(path.rstrip(\\\"/\\\"))\\n if device == \\\"dut\\\":\\n st.config(conn_obj, command)\\n else:\\n conn_obj.execute_command(conn_obj, command)\\n return True\",\n \"def prepare_dir(path, empty=False):\\n\\n def create_dir(path):\\n \\\"\\\"\\\"\\n Creates a directory\\n :param path: string\\n :return: nothing\\n \\\"\\\"\\\"\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno != errno.EEXIST:\\n raise\\n\\n if not os.path.exists(path):\\n create_dir(path)\",\n \"def addEmptyDir(self, path, baseToRemove=\\\"\\\", inZipRoot=None):\\n\\t\\tinZipPath = os.path.relpath(path, baseToRemove)\\n\\t\\tif inZipPath == \\\".\\\":\\t# path == baseToRemove (but still root might be added\\n\\t\\t\\tinZipPath = \\\"\\\"\\n\\t\\t\\n\\t\\tif inZipRoot!=None:\\n\\t\\t\\tinZipPath = os.path.join(inZipRoot, inZipPath)\\n\\t\\t\\n\\t\\tif inZipPath == \\\"\\\":\\t\\t# nothing to add\\n\\t\\t\\treturn\\n\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint \\\"Adding dir entry: \\\" + inZipPath\\n\\t\\tzipInfo = zipfile.ZipInfo(os.path.join(inZipPath, ''))\\n\\t\\tself.writestr(zipInfo, '')\",\n \"def clean_dirs(output_dir):\\n if os.path.exists(output_dir):\\n shutil.rmtree(output_dir)\\n os.makedirs(output_dir)\",\n \"def remove_directory(tracking_id):\\n complete_path = os.path.join(app.config['DRS_UPLOADS'], '{0}'.format(tracking_id))\\n if os.path.isdir(complete_path):\\n shutil.rmtree(complete_path, ignore_errors=False, onerror=None)\\n return\",\n \"def clearDirs(self):\\n if self.listDirs.count() == 0:\\n QtGui.QMessageBox.warning(self, \\\"Wait a second!\\\", \\\"Looks like you have nothing to clear.\\\")\\n return\\n # Confirmation Dialog\\n sure = QtGui.QMessageBox.question(self, \\\"Confirm\\\", \\\"Are you sure?\\\",\\n QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel, QtGui.QMessageBox.Cancel)\\n if sure == QtGui.QMessageBox.Ok:\\n self.listDirs.clear()\\n self.listFiles.clear()\",\n \"def clean_home_subdir(self):\\n\\n self.log.debug(\\\"Cleaning up %s...\\\" % self.home_subdir_local)\\n try:\\n for tree in os.listdir(self.home_subdir_local):\\n self.log.debug(\\\"... removing %s subtree\\\" % tree)\\n path = os.path.join(self.home_subdir_local, tree)\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n except OSError, err:\\n self.log.error(\\\"Cleaning up intel dir %s failed: %s\\\" % (self.home_subdir_local, err))\",\n \"def rmdir(folder_name: str) -> None:\\n if not exist(folder_name):\\n print(\\\"The folder does not exist\\\")\\n return\\n \\n os.rmdir(folder_name)\",\n \"def _remove_object_directory(directory):\\n if not directory.exists():\\n raise IOError(\\\"The directory '\\\" + str(directory) + \\\"' does not exist\\\")\\n assert is_inside_exdir(directory)\\n shutil.rmtree(directory)\",\n \"def verify_directories_empty(self):\\n if self.install_type == \\\"rpm\\\":\\n return # For RPM install we don't want to clean anything\\n\\n instance_dir = \\\"frontend_%(service)s-%(instance)s\\\" % \\\\\\n { \\\"service\\\": self.service_name(), \\n \\\"instance\\\": self.glidein.instance_name(), }\\n #-- directories to check ---\\n dirs = {}\\n dirs[\\\"logs........\\\"] = os.path.join(self.logs_dir(), instance_dir)\\n dirs[\\\"install.....\\\"] = os.path.join(self.install_location(), instance_dir) \\n dirs[\\\"config......\\\"] = self.config_dir()\\n for subdir in [\\\"monitor\\\", \\\"stage\\\"]:\\n dirs[\\\"web %s \\\" % subdir] = os.path.join(self.glidein.web_location(), subdir, instance_dir)\\n #--- check them --\\n for type in dirs.keys():\\n if os.path.isdir(dirs[type]): \\n if len(os.listdir(dirs[type])) == 0:\\n os.rmdir(dirs[type])\\n del dirs[type] # remove from dict\\n else:\\n del dirs[type] # it does not exist, remove from dict\\n\\n #--- if all are empty, return \\n if len(dirs) == 0:\\n time.sleep(3)\\n return # all directories are empty\\n\\n #--- See if we can remove them --- \\n common.logit(\\\"\\\"\\\"The following directories must be empty for the install to succeed: \\\"\\\"\\\")\\n types = sorted(dirs.keys())\\n for type in types:\\n common.logit(\\\"\\\"\\\" %(type)s: %(dir)s\\\"\\\"\\\" % \\\\\\n { \\\"type\\\" : type, \\\"dir\\\" : dirs[type] })\\n common.ask_continue(\\\"... can we remove their contents\\\")\\n for type in dirs.keys():\\n common.remove_dir_contents(dirs[type])\\n os.rmdir(dirs[type])\\n time.sleep(3)\\n return\",\n \"def wipe_dir(fDic):\\n if os.path.exists(fDic['topDir']):\\n ans = input('The Directory Tree Structure for output already exists' +\\n ' enter Y/N to erase directory.')\\n if ans.upper() == 'Y':\\n shutil.rmtree(fDic['topDir'])\\n if not os.path.exists(fDic['topDir']) :\\n # https://docs.python.org/2/library/os.html#files-and-directories\\n os.makedirs(fDic['topDir'])\\n os.makedirs(fDic['topDir'] + fDic['noHit'])\",\n \"def shred_dir(directory):\\n # Remove directory content\\n for root, dirs, files in os.walk(directory, topdown=False):\\n for fname in files:\\n filepath = os_join(root, fname)\\n LOG.info('Clean file %s' % fname)\\n run_cmd('shred -f --remove %s' % filepath)\\n for dname in dirs:\\n dpath = os_join(root, dname)\\n os.rmdir('%s' % dpath)\\n # Remove the directory\\n os.rmdir(directory)\",\n \"def cleanOutputDir(output):\\n if os.path.exists(output) and os.path.isdir(output):\\n shutil.rmtree(output)\",\n \"def delete_folder(self, path):\\n if not path_exists(path, self._store_folder):\\n raise NotFoundException(\\\"\\\")\\n rmdir(path)\",\n \"def drop_empty_folders(BaseFolder):\\n\\n for root, dirs, files in os.walk(BaseFolder, topdown=False):\\n if not dirs and not files:\\n os.rmdir(root)\",\n \"def mkdir(self, directory):\\n self.logger.info(f\\\"remove and mkdir {directory}\\\")\\n self.conn.run(f\\\"rm -rf {directory}\\\", hide=True)\\n self.conn.run(f\\\"mkdir -p {directory}\\\", hide=True)\\n return directory\",\n \"def cleanup(self):\\n\\n # check if the directory exists\\n if not os.path.exists(self.path):\\n return\\n\\n # check if the directory is a directory\\n if not os.path.isdir(self.path):\\n return\\n\\n # loop over content of directory and remove it\\n for the_file in os.listdir(self.path):\\n file_path = os.path.join(self.path, the_file)\\n try:\\n if os.path.isfile(file_path):\\n os.unlink(file_path)\\n elif os.path.isdir(file_path):\\n shutil.rmtree(file_path)\\n except Exception as e:\\n pass\",\n \"def clean_dist(dist_directory):\\n\\n # Remove the old folder.\\n shutil.rmtree(dist_directory, ignore_errors=True)\\n\\n # Create a new one\\n os.mkdir(dist_directory)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8056177","0.78796035","0.7780004","0.7707977","0.7627978","0.7590993","0.75686836","0.75058484","0.7489895","0.7464971","0.74595416","0.7390957","0.7353166","0.7352782","0.7333176","0.7274257","0.725936","0.7209765","0.7153305","0.71452975","0.71025324","0.7102245","0.7101515","0.7095589","0.7054016","0.70440227","0.70365703","0.70162034","0.69715476","0.69360083","0.6931133","0.6901456","0.6890327","0.687866","0.6865764","0.68619376","0.68598884","0.68209976","0.6817937","0.67885894","0.6765398","0.6756088","0.6742228","0.67320174","0.6729505","0.6724934","0.67187774","0.66899854","0.6662305","0.664657","0.6633622","0.6627526","0.6627526","0.66195524","0.6616168","0.6614375","0.66099566","0.6606487","0.6581071","0.6570001","0.65639436","0.65534717","0.65498745","0.6544395","0.654418","0.6536546","0.6527697","0.65260386","0.6516882","0.6516882","0.65015745","0.64969444","0.6492122","0.64877504","0.64877504","0.6463943","0.646199","0.64554745","0.6454686","0.6453811","0.64516646","0.64483273","0.64438283","0.64409447","0.6438493","0.6431627","0.64272594","0.64208794","0.64200574","0.6416154","0.6415403","0.6414792","0.63982195","0.63975","0.63918066","0.63848335","0.637035","0.636982","0.63532215","0.63529277","0.63314986"],"string":"[\n \"0.8056177\",\n \"0.78796035\",\n \"0.7780004\",\n \"0.7707977\",\n \"0.7627978\",\n \"0.7590993\",\n \"0.75686836\",\n \"0.75058484\",\n \"0.7489895\",\n \"0.7464971\",\n \"0.74595416\",\n \"0.7390957\",\n \"0.7353166\",\n \"0.7352782\",\n \"0.7333176\",\n \"0.7274257\",\n \"0.725936\",\n \"0.7209765\",\n \"0.7153305\",\n \"0.71452975\",\n \"0.71025324\",\n \"0.7102245\",\n \"0.7101515\",\n \"0.7095589\",\n \"0.7054016\",\n \"0.70440227\",\n \"0.70365703\",\n \"0.70162034\",\n \"0.69715476\",\n \"0.69360083\",\n \"0.6931133\",\n \"0.6901456\",\n \"0.6890327\",\n \"0.687866\",\n \"0.6865764\",\n \"0.68619376\",\n \"0.68598884\",\n \"0.68209976\",\n \"0.6817937\",\n \"0.67885894\",\n \"0.6765398\",\n \"0.6756088\",\n \"0.6742228\",\n \"0.67320174\",\n \"0.6729505\",\n \"0.6724934\",\n \"0.67187774\",\n \"0.66899854\",\n \"0.6662305\",\n \"0.664657\",\n \"0.6633622\",\n \"0.6627526\",\n \"0.6627526\",\n \"0.66195524\",\n \"0.6616168\",\n \"0.6614375\",\n \"0.66099566\",\n \"0.6606487\",\n \"0.6581071\",\n \"0.6570001\",\n \"0.65639436\",\n \"0.65534717\",\n \"0.65498745\",\n \"0.6544395\",\n \"0.654418\",\n \"0.6536546\",\n \"0.6527697\",\n \"0.65260386\",\n \"0.6516882\",\n \"0.6516882\",\n \"0.65015745\",\n \"0.64969444\",\n \"0.6492122\",\n \"0.64877504\",\n \"0.64877504\",\n \"0.6463943\",\n \"0.646199\",\n \"0.64554745\",\n \"0.6454686\",\n \"0.6453811\",\n \"0.64516646\",\n \"0.64483273\",\n \"0.64438283\",\n \"0.64409447\",\n \"0.6438493\",\n \"0.6431627\",\n \"0.64272594\",\n \"0.64208794\",\n \"0.64200574\",\n \"0.6416154\",\n \"0.6415403\",\n \"0.6414792\",\n \"0.63982195\",\n \"0.63975\",\n \"0.63918066\",\n \"0.63848335\",\n \"0.637035\",\n \"0.636982\",\n \"0.63532215\",\n \"0.63529277\",\n \"0.63314986\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9481,"cells":{"query":{"kind":"string","value":"Create a k cluster data set with required separation. For the purposes of validating a proof, generate each cluster center such that it is at least 4 delta away from any other cluster for some value of delta > 0."},"document":{"kind":"string","value":"def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta"},"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 create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def generate_k(data_set, k):\n centers = []\n dimensions = len(data_set[0])\n min_max = defaultdict(int)\n\n for point in data_set:\n for i in range(dimensions):\n val = point[i]\n min_key = 'min_{0}d'.format(i)\n max_key = 'max_{0}d'.format(i)\n if min_key not in min_max or val < min_max[min_key]:\n min_max[min_key] = val\n if max_key not in min_max or val > min_max[max_key]:\n min_max[max_key] = val\n\n for _k in range(k):\n rand_point = []\n for i in range(dimensions):\n min_val = min_max['min_{0}d'.format(i)]\n max_val = min_max['max_{0}d'.format(i)]\n \n rand_point.append(uniform(min_val, max_val))\n centers.append(rand_point)\n return centers","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def kMeans(d, k):\n #First get the random centroids from the data\n newCentroids = getRandomCentroids(d, k)\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\n\n #Get the clusters from these random centroids\n clusters = initiateCentroid(d, newCentroids, k)\n oldCentroids = []\n\n counter = 0\n #While the old centroids are not equal to the new ones\n while oldCentroids != newCentroids:\n #old is equal to new\n oldCentroids = newCentroids\n #Calculate the new centroids\n k, newCentroids = calcCentroids(d, clusters)\n #Calculate the new clusters\n clusters = initiateCentroid(d, newCentroids, k)\n #Count how many iterations\n counter += 1\n\n return counter, clusters","def optimalK(data, nrefs=3, maxClusters=15):\r\n gaps = np.zeros((len(range(1, maxClusters)),))\r\n resultsdf = pd.DataFrame({'clusterCount':[], 'gap':[]})\r\n for gap_index, k in enumerate(range(1, maxClusters)):\r\n\r\n # Holder for reference dispersion results\r\n refDisps = np.zeros(nrefs)\r\n\r\n # For n references, generate random sample and perform kmeans getting resulting dispersion of each loop\r\n for i in range(nrefs):\r\n\r\n # Create new random reference set\r\n randomReference = np.random.random_sample(size=data.shape)\r\n\r\n # Fit to it\r\n km = KMeans(k)\r\n km.fit(randomReference)\r\n\r\n refDisp = km.inertia_\r\n refDisps[i] = refDisp\r\n\r\n # Fit cluster to original data and create dispersion\r\n km = KMeans(k)\r\n km.fit(data)\r\n print(k)\r\n\r\n origDisp = km.inertia_\r\n\r\n # Calculate gap statistic\r\n gap = np.log(np.mean(refDisps)) - np.log(origDisp)\r\n\r\n # Assign this loop's gap statistic to gaps\r\n gaps[gap_index] = gap\r\n\r\n resultsdf = resultsdf.append({'clusterCount':k, 'gap':gap}, ignore_index=True)\r\n\r\n\r\n return (gaps.argmax() + 1, resultsdf) # Plus 1 because index of 0 means 1 cluster is optimal, index 2 = 3 clusters are optimal\r","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def __generate_central_nodes(self,k=3):\n if k < 3:\n k = 3\n \n self.__logger.info(\"CENTRAL_NODES: Try to seek {} nodes which are currently central\".format(k)) \n res = [n for n,_ in sorted(nx.betweenness_centrality(self.G).items(),key=itemgetter(1),reverse=True)[:4*k]]\n self.__logger.info(\"CENTRAL_NODES: Generated top {} central nodes (according to betweeness centrality)\".format(len(res)))\n \n self.__logger.info(\"CENTRAL_NODES: Sample {} items from the candidates as was requested\".format(k))\n tmp = list(res)\n random.shuffle(tmp)\n return tmp[0:k]","def generate_clusters(df):\n\n df_size = df.shape[0]\n print(df_size)\n n_clusters = 0\n percent_min_pts = 0.105\n min_clusters = 3\n while (n_clusters != min_clusters):\n print(\"percent_min_pts\", percent_min_pts)\n min_cluster_pts = math.floor(df_size * percent_min_pts)\n print(\"min_cluster_pts\", min_cluster_pts)\n\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\n print(df.head())\n clusterer.fit(df)\n cluster_groups = {}\n labels = clusterer.labels_\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n n_clusters = len(set(labels))\n print(\"n_clusters\", n_clusters)\n multiplier = abs(n_clusters - min_clusters) * 0.001\n print(\"multiplier\", multiplier)\n if n_clusters > min_clusters:\n percent_min_pts += multiplier\n else:\n percent_min_pts -= multiplier\n print(\"percent_min_pts\", percent_min_pts)\n return labels","def create_cluster(df,validate, test, X, k, name):\n \n scaler = StandardScaler(copy=True).fit(df[X])\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\n kmeans = KMeans(n_clusters = k, random_state = 42)\n kmeans.fit(X_scaled)\n kmeans.predict(X_scaled)\n df[name] = kmeans.predict(X_scaled)\n df[name] = 'cluster_' + df[name].astype(str)\n \n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\n validate[name] = kmeans.predict(v_scaled)\n validate[name] = 'cluster_' + validate[name].astype(str)\n \n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\n test[name] = kmeans.predict(t_scaled)\n test[name] = 'cluster_' + test[name].astype(str)\n \n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\n return df, X_scaled, scaler, kmeans, centroids","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def cluster(self, k=3, max_iter=10):\n\n # create a set of k random clusters as seeds\n old_clusters = [None] * k # just a placeholder\n clusters = self.random_clusters(k)\n\n iter = 0\n while (iter < max_iter) and not (old_clusters == clusters):\n print \"iteration %d...\" % iter\n # assign new clusters to old clusters\n for i in xrange(0, k):\n old_clusters[i] = copy(clusters[i])\n clusters[i].documents = []\n\n # for each document\n for document in self.documents:\n\n # determine the cluster with the highest similarity\n similarities = [cosine_similarity(document, cluster) for cluster in old_clusters]\n max_index = array(similarities).argmax()\n\n # assign document to that cluster\n clusters[max_index].add(document)\n\n # update cluster means\n for cluster in clusters:\n cluster.update_centroid()\n \n iter += 1\n \n return clusters","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def _create_constrained_dataset(centers, delta, size):\n dataset = []\n count = 0\n for i, c in enumerate(centers):\n for j in range(size):\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\n direction = x / np.linalg.norm(x)\n magnitude = np.random.uniform(0.0, 0.5 * delta)\n # magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED\n dataset.append((c + magnitude * direction, i, count))\n count += 1\n return dataset","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def generate_clusterarray(k_cluster, cluster_size):\n result = np.zeros(k_cluster + 1, dtype = np.int32)\n for i in range(1,len(result)):\n result[i] = cluster_size\n return result","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def eval_kd_cluster(kmers):\n shuffle(kmers)\n search_set, kmers = kmers[:1000], kmers[1000:]\n for H in [0.15, 0.125, 0.1, 0.075, 0.05]:\n kdrft_cover = KDRFTCover(H)\n\n start = clock()\n for kmer in kmers:\n kdrft_cover.add(kmer)\n kdrft_cover.greedy_clusters()\n build_time = clock() - start\n\n stats = kdrft_cover.stats()\n stats['build_time'] = build_time\n stats['H'] = H\n\n start = clock()\n for kmer in search_set:\n kdrft_cover.search(kmer, 2)\n stats['search_time'] = (clock() - start)\n yield stats","def generate_clusters_n(df, tweet_deleted):\n # cluster_labels, n_clusters = dbscan(normalised_df, true_labels, 0.25, 30)\n # print(\"normalised_df.head()\", normalised_df.head())\n clusterer = hdbscan.HDBSCAN(min_cluster_size=10)\n clusterer.fit(df)\n labels = clusterer.labels_\n cluster_groups = {}\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n df[\"cluster\"] = labels\n df[\"tweet_deleted\"] = tweet_deleted\n cluster_results = list()\n for cluster_no in cluster_groups.keys():\n print(\"++++++++++\")\n print(\"cluster_no\", cluster_no)\n cluster_result = list()\n cluster_result.append(cluster_no)\n\n cluster = df.mask('cluster', cluster_no)\n print(cluster_no, \" :\")\n tweet_deleted = cluster.mask('tweet_deleted', True).shape[0]\n not_tweet_deleted = cluster.mask('tweet_deleted', False).shape[0]\n print(\"deleted_df len:\", tweet_deleted)\n print(\"not_deleted_df len:\", not_tweet_deleted)","def determine_k(dataset, range_k, n_seed=30):\r\n range_Ks = np.arange(0,range_k,1,dtype=int) #range of delays to study\r\n h_K=np.zeros((10,range_k))\r\n \r\n for i in range(10):\r\n for k, K in enumerate(range_Ks):\r\n traj_matrix= embed.trajectory_matrix(dataset, K=K)\r\n labels= cl.kmeans_knn_partition(traj_matrix, n_seed)\r\n h= op_calc.get_entropy(labels)\r\n h_K[i,k]=h\r\n \r\n return(h_K)","def distortion_of_kmeans_clustering(data_table):\n num_iritations = 5\n singleton_list = []\n for line in data_table:\n singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\n distortion_list = []\n for num in range(20, 5, -1):\n cluster_list = kmeans_clustering(singleton_list,num, num_iritations)\n distortion = compute_distortion(data_table, cluster_list)\n distortion_list.append(distortion)\n return distortion_list\n\n#####################################################################\n# Code to load cancer data, compute a clustering and\n# visualize the results\n\n\n# def run_example():\n# \"\"\"\n# Load a data table, compute a list of clusters and\n# plot a list of clusters\n#\n# Set DESKTOP = True/False to use either matplotlib or simplegui\n# \"\"\"\n# data_table = load_data_table(DATA_3108_URL)\n# singleton_list = []\n# for line in data_table:\n# singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\n num_clusters = 16\n # cluster_list = sequential_clustering(singleton_list, num_clusters)\n # print(\"Displaying\", len(cluster_list), \"sequential clusters\")\n #\n # cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, num_clusters)\n # print(\"Displaying\", len(cluster_list), \"hierarchical clusters\")\n #\n # cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, num_clusters, 5)\n # print(\"Displaying\", len(cluster_list), \"k-means clusters\")\n\n # draw the clusters using matplotlib or simplegui\n #\n # if DESKTOP:\n # # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, False)\n # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, True) #add cluster centers\n\n # else:\n # alg_clusters_simplegui.PlotClusters(data_table, cluster_list) # use toggle in GUI to add cluster centers","def hierarchical_clustering(cluster_list, num_clusters):\n # n <-- |P|\n len_cluster_list = len(cluster_list)\n \n # Initialize n clusters C = {C1, ... Cn} such that Ci = {pi};\n new_cluster_list = []\n\n for index in range(len_cluster_list):\n new_cluster_list.append(alg_cluster.Cluster(cluster_list[index].fips_codes(), cluster_list[index].horiz_center(), cluster_list[index].vert_center(), cluster_list[index].total_population(), cluster_list[index].averaged_risk()))\n\n # while |C| > k do\n while len(new_cluster_list) > num_clusters:\n # (Ci,Cj) <-- argminCi,Cj Element C, i != j^dCi,Cj;\n # C <-- C Union {Ci Union Cj}; // line 5\n # C <-- C \\ {Ci, Cj}; // line 6\n fc_pair = fast_closest_pair(new_cluster_list)\n # print \"\\nfc_pair:\", fc_pair, \"\\n\"\n new_cluster_list[fc_pair[1]].merge_clusters(new_cluster_list[fc_pair[2]])\n del new_cluster_list[fc_pair[2]]\n\n return new_cluster_list","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n\n # Scale the data so that Euclidian distance makes sense\n means = np.mean(data, axis = 0)\n stddevs = np.std(data, axis = 0, ddof = 1)\n\n #print(means)\n #print(stddevs)\n\n data_scaled = np.zeros((n_examples, n_features))\n\n for i in range(n_features):\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\n\n study_correlation(data_scaled)\n\n # Initialize the centroids\n idx = np.random.randint(n_examples, size = n_clusters)\n centroids = data_scaled[idx, :]\n\n counter = 0\n\n while True:\n\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\n centroid_idx = np.argmin(distances, axis = 1)\n old_centroids = centroids\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\n #displacement = get_displacement(old_centroids, centroids)\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\n\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\n\n if counter == 0:\n# print(\"Initial displacement = {}\".format(displacement))\n initial_displacement = displacement\n\n counter += 1\n\n if displacement < (initial_displacement / 10000): break\n\n #print(\"Total number of loops before ending : {}\".format(counter))\n converted_predictions = convert_predictions(centroid_idx)\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def cluster_dpc_knn(token_dict, cluster_num, k=5, token_mask=None):\n with torch.no_grad():\n x = token_dict['x']\n B, N, C = x.shape\n dist_matrix = torch.cdist(x, x) / C ** 0.5\n if token_mask is not None:\n token_mask = token_mask > 0\n dist_matrix = dist_matrix * token_mask[:, None, :] + (dist_matrix.max() + 1) * ~token_mask[:, None, :]\n dist_nearest, index_nearest = torch.topk(dist_matrix, k=k, dim=-1, largest=False)\n density = (-(dist_nearest ** 2).mean(dim=-1)).exp()\n density = density + torch.rand(density.shape, device=density.device, dtype=density.dtype) * 1e-06\n if token_mask is not None:\n density = density * token_mask\n mask = density[:, None, :] > density[:, :, None]\n mask = mask.type(x.dtype)\n dist_max = dist_matrix.flatten(1).max(dim=-1)[0][:, None, None]\n dist, index_parent = (dist_matrix * mask + dist_max * (1 - mask)).min(dim=-1)\n score = dist * density\n _, index_down = torch.topk(score, k=cluster_num, dim=-1)\n dist_matrix = index_points(dist_matrix, index_down)\n idx_cluster = dist_matrix.argmin(dim=1)\n idx_batch = torch.arange(B, device=x.device)[:, None].expand(B, cluster_num)\n idx_tmp = torch.arange(cluster_num, device=x.device)[None, :].expand(B, cluster_num)\n idx_cluster[idx_batch.reshape(-1), index_down.reshape(-1)] = idx_tmp.reshape(-1)\n return idx_cluster, cluster_num","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def diameter_clustering_vs_prob_ws(num_nodes, k):\r\n xdata = []\r\n ydata = []\r\n zdata = []\r\n prob = 0.0005\r\n while prob < 1:\r\n xdata += [prob]\r\n diameters = []\r\n coeffs = []\r\n for i in range(k):\r\n graph = make_ws_graph(num_nodes, 8, prob)\r\n diameters += [diameter(graph)]\r\n coeffs += [clustering_coefficient(graph)]\r\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\r\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\r\n prob = 1.2*prob\r\n return xdata, ydata, zdata","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\ttotal_clusters = len(cluster_list)\n\tclusters = sorted(cluster_list, key = lambda cluster: \\\n\t\t\t\t\t cluster.total_population(), reverse = True)\n\tk_clusters = clusters[:num_clusters]\n\tfor dummy_idx_i in range(num_iterations):\n\t\tk_empties = [Cluster(set([]), 0, 0, 0, 0) for \\\n\t\t\t\t\t dummy_idx in range(num_clusters)]\n\t\tfor idx_j in range(total_clusters):\n\t\t\tdist = [cluster_list[idx_j].distance(k_clusters[idx_f]) for \\\n\t\t\t\t\tidx_f in range(num_clusters)]\n\t\t\tidx_l = dist.index(min(dist))\n\t\t\tk_empties[idx_l].merge_clusters(cluster_list[idx_j])\n\t\tk_clusters = k_empties[:]\n\treturn k_clusters","def kmeans_clustering(self,k):\r\n \r\n print(colored(\"Performing K-means clustering with %d clusters\\n\"%k,color = 'yellow', attrs=['bold']))\r\n kmeans = KMeans(n_clusters=k, random_state=0, n_init=10, max_iter=100, n_jobs=-1, ).fit(self.X)\r\n self.labels = kmeans.labels_\r\n self.davies_bouldin_score()\r\n print()\r\n print(colored(\"The k-means inertia is %0.002f\\n\" %(kmeans.inertia_),color = 'red', attrs=['bold']))\r\n self.cluster_plot()\r\n return self.labels , kmeans.cluster_centers_,kmeans","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\n\n # Your code here. You should also change the return value.\n\n def _initiate_random_centroids(all_features, vocab_size):\n \"\"\"\n Initiate random centroids in the range of input\n\n :param all_features:\n :param vocab_size:\n :return:\n \"\"\"\n centroids = []\n # 1) Genereate points for initial centroids\n\n min_feat = np.ones(all_features[0].size)*np.inf\n max_feat = np.zeros(all_features[0].size)\n\n for a in all_features:\n for p in range(len(a)):\n if a[p] < min_feat[p]:\n min_feat[p] = a[p]\n else:\n if a[p] > max_feat[p]:\n max_feat[p] = a[p]\n\n\n for _ in range(vocab_size):\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\n max_feat-min_feat) + min_feat\n centroids.append(random_vector.flatten())\n\n return np.array(centroids)\n\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\n \"\"\"\n Assign vectors to nearest centroids\n\n :param all_features:\n :param centroid:\n :return:\n \"\"\"\n #TODO: sprawdz co lepiej dziala\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\n #new_centroid_coor = centroid\n new_centroid_counter = np.zeros(len(centroid))\n\n dist = pdist(centroid, all_features)\n #min_dist = dist.min(axis=0)\n min_dist_index = dist.argmin(axis=0)\n\n for x in range(len(min_dist_index)):\n id = min_dist_index[x]\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\n all_features[x])\n new_centroid_counter[id] += 1\n\n new_centroid_coor_out = []\n for i in range(len(new_centroid_coor)):\n if new_centroid_counter[i] == 0:\n new_centroid_coor_out.append(centroid[i])\n else:\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\n\n return np.array(new_centroid_coor_out), new_centroid_counter\n\n\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\n \"\"\"\n Check convergence confition\n\n :param old_centroids:\n :param new_centroids:\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\n :return:\n \"\"\"\n for i in range(len(old_centroids)):\n dist = euclidean(old_centroids[i], new_centroids[i])\n if dist > epsilon:\n return False\n\n return True\n\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\n \"\"\"\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\n\n :param new_centroids:\n :param centroid_counter:\n :param threshold:\n :return:\n \"\"\"\n\n out_centroids = []\n for n in range(len(new_centroids)):\n if centroid_counter[n] > threshold:\n out_centroids.append(new_centroids[n])\n out_centroids = np.array(out_centroids)\n return out_centroids\n\n #MAIN\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\n\n for _ in range(max_iter):\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\n\n if if_convergenced == True:\n # return centroids if algorithm is converged\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids\n old_centroids = new_centroids\n\n # return centroids if reached max_iter\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def cluster_kmeans(df, k):\r\n # Sample fron the original df\r\n sample_df=df.sample(n = k)\r\n obs, attr= df.shape\r\n # Make copies \r\n copy_df=df.copy()\r\n flag=0\r\n sse_old=0\r\n while (flag==0): \r\n sse=0\r\n Labels=[]\r\n for i in range(0, obs):\r\n dist= []\r\n for j in range(0,k):\r\n #Calculate Eucledian distance\r\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\r\n eu_dist=(sum(diff))**(1/attr)\r\n dist.append(eu_dist) \r\n #Add Labels to the observations based on the variable they are close to\r\n label=(dist.index(min(dist)))\r\n Labels.append(label)\r\n # Calculate SSE\r\n sse=sse+((min(dist) )**2)\r\n sse=sse**(1/2)\r\n copy_df['labels']=Labels\r\n # Stopping criteria is change in SSE should be 2 %\r\n if (sse_old !=0):\r\n if(abs(sse_old-sse)/sse_old<=0.05):\r\n flag=1 \r\n return_df=copy_df['labels'].to_frame()\r\n return (return_df, sse)\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n # Now pick random values from each label and add it to the sample df\r\n for val in range(0,k):\r\n #Create new sample df\r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n for val in range(0,k):\r\n #Create new sample df \r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\r\n ds_arr_ones = []\r\n for clus in SOM_clusters_block:\r\n node_cluster_set_test = [clus]\r\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\r\n #calculate the blocked days which the new cluster determines\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\r\n #calculate precision, recall and F1\r\n if len(str(node_cluster_set_test)) == 1:\r\n comb_str = f\"{node_cluster_set_test[0]}\".replace(\"'\", \"\")\r\n else:\r\n comb_str = f\"{str(node_cluster_set_test)[1:-1]}\".replace(\"'\", \"\") \r\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\r\n ds_arr_ones.append(ds)\r\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \"set\")\r\n return blocks_one_clusnum","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def clusterGen(k, colors):\n clusters = []\n # generate the clusters randomly\n # for i in range(k):\n # r = random.randint(0, 255)\n # g = random.randint(0, 255)\n # b = random.randint(0, 255)\n # clusters.append((r, g, b))\n\n # generate the clusters that exist in colors\n l = len(colors)\n for i in range(k):\n r = random.randint(0, l)\n cluster = colors[r][1]\n clusters.append(cluster)\n\n return clusters","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def private_center_recovery(\n raw_data,\n cluster_assignment,\n norm,\n epsilon,\n delta,\n):\n\n cluster_ids = np.unique(cluster_assignment)\n _, d = raw_data.shape\n centers = []\n for _ in range(max(cluster_ids) + 1):\n centers.append(np.zeros(d))\n\n for c_id in cluster_ids:\n points = raw_data[c_id == cluster_assignment]\n if np.size(points) == 0:\n centers[c_id] = np.random.uniform(-norm, norm)\n centers[c_id] = private_centers(points, norm, epsilon, delta)\n return np.vstack(centers)","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def integrated_clustering(t_all,y_all,num_of_days=500,period = 1440,trim=10,min_n_clusters = 4, max_n_clusters=10,hierarchical=0):\n\n\n\n all_seg_april = initial_disaggregate(t_all,y_all,num_of_days,period = period)\n \n ''' '''\n all_seg_april_normalized = [np.array(x[0])-np.mean(x[1]) for x in all_seg_april if len(x[1])==3]\n \n ''' filter the empty segments'''\n all_seg_april_normalized = [x for x in all_seg_april_normalized if len(x)>0]\n \n ''' clustering in different ranges will probably have a better result'''\n if hierarchical == 0:\n pass\n elif hierarchical ==1:\n all_seg_april_normalized = [x for x in all_seg_april_normalized if x.mean()>1000]\n else:\n all_seg_april_normalized = [x for x in all_seg_april_normalized if x.mean()<1000]\n \n ''' filter out the positive segments'''\n all_positive_seg_april_normalized = [x for x in all_seg_april_normalized if x.min()>0]\n \n \n all_seg_april_normalized_trim50 = extract_first_n(all_positive_seg_april_normalized, trim)\n cluster_average = []\n \n # find optimal clustering number using silhouette score\n \n optimal_dict = {}\n \n for n_clusters in range(min_n_clusters,max_n_clusters):\n \n y_pred = KMeans(n_clusters=n_clusters).fit_predict(all_seg_april_normalized_trim50)\n\n cluster_average = []\n for i_cluster in range(n_clusters):\n cluster_average.append(\n np.mean([np.mean(x) for i, x in enumerate(all_seg_april_normalized_trim50) if y_pred[i]==i_cluster])\n ) \n\n # sihouette score\n cluster_labels = y_pred\n sample_silhouette_values = silhouette_samples(all_seg_april_normalized_trim50, cluster_labels)\n \n silhouette_avg = silhouette_score(pd.DataFrame(all_seg_april_normalized_trim50), cluster_labels)\n\n optimal_dict[n_clusters] = silhouette_avg +(sample_silhouette_values.min()+sample_silhouette_values.max())/2\n \n # n_clusters will give us the optimal number of clusters\n n_clusters = max(optimal_dict.iteritems(), key=operator.itemgetter(1))[0]\n\n #print n_clusters\n \n y_pred = KMeans(n_clusters=n_clusters).fit_predict(all_seg_april_normalized_trim50)\n\n cluster_average = []\n \n for i_cluster in range(n_clusters):\n cluster_average.append(\n np.mean([np.mean(x) for i, x in enumerate(all_seg_april_normalized_trim50) if y_pred[i]==i_cluster])\n ) \n cluster_average_rank = np.argsort(cluster_average)[::-1]\n rank_map = {cluster_average_rank[i_cluster]:i_cluster for i_cluster in range(n_clusters)} # old index:new index\n\n y_pred_old = y_pred\n y_pred = [rank_map[x] for x in y_pred]\n all_seg_per_cluster = [[] for i in range(n_clusters) ]\n for i_seg in range(len(all_seg_april_normalized_trim50)):\n all_seg_per_cluster[y_pred[i_seg]].append(all_seg_april_normalized_trim50[i_seg])\n \n cluster_mean = [[] for i in range(n_clusters) ]\n cluster_std = [[] for i in range(n_clusters) ]\n for i_cluster in range(n_clusters):\n cluster_mean[ i_cluster ] = np.mean(np.array(all_seg_per_cluster[i_cluster]), axis=0)\n cluster_std[ i_cluster ] = np.std(np.array(all_seg_per_cluster[i_cluster]), axis=0)\n \n \n \n \n #cluster_mean_2 = cluster_mean[5:6]\n \n return cluster_mean,cluster_std,n_clusters,all_seg_per_cluster","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def kmeans_fast(features, k, num_iters=100):\n N = len(features)\n print(N)\n # Randomly initalize cluster centers\n centers, assignments = np.array([features[i] for i in sorted(random.sample(range(0, len(features)), K))]), {}\n _, dim = centers.shape\n\n tile_f = np.tile(features, (k, 1))\n for n in range(num_iters):\n tile_c = np.repeat(centers, N, axis=0)\n tile_sub = np.subtract(tile_f, tile_c)\n dist = np.linalg.norm(tile_sub, axis=1).reshape(k, N)\n assignments_new = np.argmin(dist, axis=0)\n if np.array_equal(assignments, assignments_new):\n break\n else:\n assignments = assignments_new\n\n old_centers, new_stats = centers[:], []\n for j in range(0, k):\n new_stats.append([0, []])\n for i in range(len(features)):\n c_ind = int(assignments[i])\n num, sum_vec = new_stats[c_ind]\n sum_vec_new = np.add(sum_vec, features[i]) if len(sum_vec) > 0 else features[i]\n new_stats[c_ind] = [num + 1, sum_vec_new]\n\n new_centers = np.zeros((k, dim))\n for j in range(0, k):\n num, new_center = new_stats[j]\n new_center = np.divide(new_center, num)\n new_centers[j] = np.array(new_center)\n centers = new_centers\n\n return centers, assignments, 0","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def initiateCentroid(data_points, centroids, k):\n #Create empty list in list (amount is k)\n AvgCentroids = [[] for i in range(k)]\n\n #For each datapoint in all datapoints\n for dp in data_points:\n dis = []\n #For each centroid in centroids\n for c in range(len(centroids)):\n #Calculate the euclidean distance between those points and append\n #to distance list\n dis.append(calcEuclideanDistance(dp, centroids[c]))\n \n #Get the smallest value of the list and the index\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\n\n #The index of the smallest value is the index where it will be added\n #to the avgCentroids list. So it represents the number of the cluster\n AvgCentroids[idx].append(dp)\n \n return AvgCentroids","def run_k_means(self):\r\n centroids = self.centroids\r\n\r\n for i in range(self.max_iters):\r\n self.closestcentroids()\r\n self.newcentroids()\r\n\r\n J = 0\r\n X = self.x\r\n m = len(X)\r\n idx = self.index\r\n K = self.K\r\n dim = X.shape[1]\r\n\r\n for num in range(K):\r\n # find the index of all entries where idx==n\r\n indexentries = np.nonzero(idx == num)[0]\r\n # the values in X that have the index in indesxentries\r\n values = X[indexentries]\r\n # using one of the K centroids to do the calculation. K<=2 doesn't\r\n # work here for some reason.\r\n centroid = centroids[num, 0]\r\n J += np.sum((values - centroid) ** 2)\r\n\r\n return [centroids.reshape((1, K, dim)), [X[idx == k].size for k in range(K)], J / m]","def get_k_by_gap_statistic(data, nrefs=5):\n\n number_of_clusters = range(2, 15)\n\n gaps = np.zeros((len(number_of_clusters),))\n\n for gap_index, k in enumerate(number_of_clusters):\n\n # Holder for reference dispersion results\n ref_disps = np.zeros(nrefs)\n\n # For n references, generate random sample and perform kmeans getting resulting dispersion of each loop\n for i in range(nrefs):\n # Create new random reference set\n random_reference = np.random.random_sample(size=data.shape)\n\n # Fit to it\n km = KMeans(n_clusters=k, init='k-means++', n_init=30,\n precompute_distances=True, verbose=0, copy_x=True, n_jobs=-1)\n km.fit(random_reference)\n\n ref_disp = km.inertia_\n ref_disps[i] = ref_disp\n\n # Fit cluster to original data and create dispersion\n km = KMeans(n_clusters=k, init='k-means++', n_init=30,\n precompute_distances=True, verbose=0, copy_x=True, n_jobs=-1)\n km.fit(data)\n\n orig_disp = km.inertia_\n\n # Calculate gap statistic\n gap = np.log(np.mean(ref_disps)) - np.log(orig_disp)\n\n # Assign this loop's gap statistic to gaps\n gaps[gap_index] = gap\n\n # Plus 1 because index of 0 means 1 cluster is optimal, index 2 = 3 clusters are optimal\n return gaps.argmax() + 1","def kmeans(self,mydata, k=None, centroids=None, steps=200):\n\t\tif centroids is not None and k is not None:\n\t\t\tassert(k == len(centroids))\n\t\telif centroids is not None:\n\t\t\tk = len(centroids)\n\t\telif k is not None:\n\t\t\t# Forgy initialization method: choose k data points randomly.\n\t\t\tcentroids = mydata[np.random.choice(np.arange(len(mydata)), k, False)]\n\t\telse:\n\t\t\traise RuntimeError(\"Need a value for k or centroids.\")\n\n\t\tfor _ in range(max(steps, 1)):\n\t\t\t# Squared distances between each point and each centroid.\n\t\t\tsqdists = scipy.spatial.distance.cdist(centroids, mydata, 'sqeuclidean')\n\n\t\t\t# Index of the closest centroid to each data point.\n\t\t\tclusters = np.argmin(sqdists, axis=0)\n\n\t\t\tnew_centroids = self.cluster_centroids(mydata, clusters, k)\n\t\t\tif np.array_equal(new_centroids, centroids):\n\t\t\t\tbreak\n\n\t\t\tcentroids = new_centroids\n\n\t\treturn clusters","def make_all_zero(curr_clusters, k, num_of_cords):\r\n for i in range(k):\r\n for j in range(num_of_cords):\r\n curr_clusters[i][j] = 0","def test_determine_k(self):\n test_dir_name = os.path.dirname(__file__)\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"four_clusters.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\"x\", \"y\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 4)\n\n feat_array_fn = os.path.join(\n test_dir_name, \"data\", \"iris.csv\")\n df = pd.read_csv(feat_array_fn)\n feat_array = df[[\n \"Sepal.Length\", \"Sepal.Width\", \"Petal.Length\",\n \"Petal.Width\"]].values\n\n clusterer = Clusterer(feat_array_fn, \"/dev/null\", [])\n best_k = clusterer._determine_k(feat_array, 9)\n\n self.assertEqual(best_k, 2)","def _cmeans0_kth(data, u_old, c, m, *para):\n\tk = para[0]\n\n\t# Normalizing, then eliminating any potential zero values.\n\tu_old /= np.ones((c, 1)).dot(np.atleast_2d(u_old.sum(axis=0)))\n\tu_old = np.fmax(u_old, np.finfo(np.float64).eps)\n\n\tum = u_old ** m\n\n\t# remain the belonging rate >= the k-th max location of each cluster in um_c\n\tfilter_k = lambda row:row < sorted(row, reverse=True)[k-1]\n\tfail_indices = np.apply_along_axis(filter_k, axis=1, arr=u_old)\n\tum[fail_indices] = 0\n\n\t# Calculate cluster centers\n\t# data1:2861,2; um:30,2861\n\tdata = data.T\n\tcntr = um.dot(data) / (np.ones((data.shape[1],1)).dot(np.atleast_2d(um.sum(axis=1))).T)\n\td = cdistance.get_center_distance(data, cntr)\n\t\n\td = np.fmax(d, np.finfo(np.float64).eps)\n\tjm = (um * d ** 2).sum()\n\n\tu = d ** (- 2. / (m - 1))\n\tu /= np.ones((c, 1)).dot(np.atleast_2d(u.sum(axis=0)))\n\treturn cntr, u, jm, d","def cluster(S, k=None, max_iter=100, visualize=False, points=None):\n N = len(S)\n if not k: \n k = N\n\n S_bar = 1 - 2 * S\n A = random_cluster_matrix((N, k))\n\n if visualize:\n if not points: \n raise ValueError(\"Cannot visualize clustering without points.\")\n plt.ion()\n\n for _i in range(max_iter): \n # Remove empty clusters\n empty_columns = [i for i in range(k) if sum(A[:,i]) == 0]\n A = remove_clusters(A, empty_columns)\n k = len(A[0]) # Adjust number of clusters\n\n # Permute cluster membership that minimizes objective the most:\n # (a) Compute M = ~SA\n M = S_bar @ A\n\n # (b) Compute v\n MoA = M * A\n v = [min(M[i]) - sum(MoA[i]) for i in range(N)]\n\n # Check if we converged\n if isclose(sum(v), 0, abs_tol=1e-5): \n break\n\n # (c) Find the object X with the greatest optimization potential\n X = np.argmin(v)\n\n # (d) Reassign X to the cluster C where C = argmin(M[X][j]) w.r.t. j\n C = np.argmin(M[X])\n A[X] = np.zeros((k))\n A[X][C] = 1\n\n if _i % 10 == 0: \n progress(_i, max_iter)\n \n if visualize: \n plot(points, A, k) \n\n return A","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def k_means(data, k = 2, centroids = None, max_iters = 100) :\r\n if centroids == None :\r\n centroids = get_random_centroids(data, k)\r\n \r\n elif len(centroids) != k :\r\n AssertionError(\"Número de centroides no equivale a k\")\r\n \r\n for i in range(max_iters) :\r\n old_centroids = centroids\r\n \r\n assigned_centroids = assign_centroids(data, centroids)\r\n \r\n # Sum the data by cluster\r\n centroids = [[0]*data.shape[1]] * k\r\n values_in_centroid = [0] * k\r\n\r\n for i in range(k) :\r\n assigned_centroids_aux = np.column_stack([assigned_centroids]*data.shape[1])==i\r\n centroids[i] = np.sum(np.multiply(data, assigned_centroids_aux), axis = 0)\r\n values_in_centroid[i] = np.sum(assigned_centroids == i)\r\n\r\n # Mean\r\n for i in range(k) :\r\n if values_in_centroid[i] > 0 :\r\n centroids[i] = centroids[i]/values_in_centroid[i]\r\n\r\n centroids = np.stack(centroids, axis=0)\r\n\r\n error = sum([np.linalg.norm(centroids[i] - old_centroids[i]) for i in range(k)])\r\n if(error < 1e-5) : break\r\n \r\n \r\n return centroids","def k_means(data, K):\n\n # randomly choose k centroids from the data points\n centroids = data[np.random.choice(len(data), size=K, replace=False)]\n\n # assign each data point to closest centroid\n distances = euclidean_distances(data, centroids)\n labels = np.array([np.argmin(i) for i in distances])\n\n # track the largest centroid movements\n deltas = []\n\n for i in range(MAX_ITERATIONS):\n # keep track of the largest centroid movement for this iteration\n max_delta_mu = 0\n\n for k in range(K):\n # get all data points with label of this centroid k\n cluster_points = data[labels == k]\n if len(cluster_points) == 0:\n continue\n\n # get mean r, g, and b values of all points in this cluster\n # e.g. mu = [112.5, 95.6, 204.2]\n mu = cluster_points.mean(axis=0)\n\n # get the max difference in an r,g, or b value\n # abs(centroids[k] - mu) will return diff in RGB values\n # e.g. abs(centroids[k] - mu) = [15.2, 25.4, 4.7]\n max_delta_mu = max(max_delta_mu, abs(centroids[k] - mu).max())\n\n # update the kth centroid to the new mean value\n centroids[k] = mu\n\n deltas.append(max_delta_mu)\n\n # assign each data point to closest centroid\n distances = euclidean_distances(data, centroids)\n labels = np.array([np.argmin(i) for i in distances])\n\n # stop the iterations early if the largest change in an r, g, or b value is < MIN_DELTA_MU\n if max_delta_mu < MIN_DELTA_MU:\n print(\n f\"reached delta_mu {max_delta_mu:.2f} < {MIN_DELTA_MU} in {i} iterations for K={K}\")\n break\n\n return centroids, labels, deltas","def solve(list_k, examples, out_path, centers_=None,\n conf_num=None, out_minus=True, out_iterations=False):\n\n # start_centers = utils.get_centers()\n dimension = len(examples[0][0])\n # print (dimension)\n N = len(examples) # print(N)\n for k in list_k:\n # sys.stderr.write(str(k) + \"\\n\")\n h = np.zeros((N, k), dtype=np.float64)\n # responsibilities.fill(1/float(k))\n pi_k = np.zeros(k, dtype=np.float64)\n pi_k.fill(1/float(k))\n # print\n configuration = False\n if centers_ == None:\n centers = utils.get_centers(k, examples)\n else:\n centers = centers_\n configuration = True\n\n matrix = np.identity(dimension, dtype=np.float64)\n matrices = np.array([matrix] * k)\n # print (matrices)\n log = calc_log(examples, centers, matrices, pi_k)\n # print (log)\n\n # output stuff\n num_iter = 0\n # if k == 4:\n # groups = [list([])] * k\n groups = []\n for i in range(k):\n groups.append([])\n probabilities = dict()\n\n # if k == 4:\n # print (h)\n # print (pi_k)\n # print (matrices)\n # print (centers)\n\n if out_iterations:\n iter_out = open(out_path + \"em-kmeans.dat\", \"w\")\n iter_out.write(\"#iteracije: log-izglednost\\n\")\n iter_out.write(\"--\\n\")\n iter_out.write(\"#0: %.2lf\\n\" % log)\n # buffer_all = \"K = %d\\n\" % k\n # number of members in a certain group\n\n while True:\n num_iter += 1\n group_count = [0] * k\n # init = dict()\n group_dicts = []\n for i in range(k):\n group_dicts.append({})\n # group_dicts = [] * k\n # E step\n # print (num_iter)\n # changed = 0\n for i in range(N):\n x = examples[i][0]\n mi_j = centers[0][0]\n sigma_j = matrices[0]\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\n h[i][0] = p\n sum_h = h[i][0]\n probabilities[i] = p\n group = examples[i][1]\n if group not in group_dicts[0]:\n group_dicts[0][group] = 1\n else:\n group_dicts[0][group] += 1\n\n # if p > \n group_count[0] += 1\n examples[i][2] = 0\n\n for j in range(1,k):\n mi_j = centers[j][0]\n sigma_j = matrices[j]\n # print (sigma_j)\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\n if p2 > p:\n group_count[examples[i][2]] -= 1\n group_dicts[examples[i][2]][group] -= 1\n if group not in group_dicts[j]:\n group_dicts[j][group] = 1\n else:\n group_dicts[j][group] += 1\n examples[i][2] = j\n group_count[j] += 1\n p = p2\n probabilities[i] = p\n\n h[i][j] = p2\n sum_h += h[i][j]\n\n h[i] /= sum_h\n probabilities[i] /= sum_h\n # print (\"$$$$$$$\")\n # M step\n # if num_iter == 1:\n # print (h)\n # sys.exit(1)\n for i in range(k):\n new_mi = np.zeros(dimension, dtype=np.float64)\n sum_h = 0.\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\n\n for j in range(N):\n x = examples[j][0]\n sum_h += h[j][i]\n new_mi += h[j][i] * x\n\n new_mi /= sum_h\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\n # changed = 1\n centers[i] = (new_mi, centers[i][1], centers[i][2])\n\n # mi = np.matrix(new_mi)\n mi = new_mi\n for j in range(N):\n x = examples[j][0]\n # print ((x-mi).T * (x - mi))\n diff = np.matrix(x - mi)\n # print (diff.T * diff)\n new_sigma += h[j][i] * (diff.T * diff)\n # break\n\n new_sigma /= sum_h\n matrices[i] = new_sigma\n new_pi = sum_h / float(N)\n pi_k[i] = new_pi\n\n # print (matrices)\n # if num_iter == 1:\n # sys.exit(1)\n\n new_log = calc_log(examples, centers, matrices, pi_k)\n\n # print (new_log)\n if abs(new_log - log) < EPS:\n break\n log = new_log\n # if k == 4:\n # print (log)\n if out_iterations:\n iter_out.write(\"#%d: %.2lf\\n\" % (num_iter, log))\n # if changed == 0:\n # break\n\n # set the groups for K = 4\n # print (groups)\n if not configuration and not out_iterations:\n if k == 4:\n for i in range(N):\n # print (examples[i][2])\n # print (groups)\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\n\n with open(out_path + \"/em-k4.dat\", \"a\") as f:\n for i in range(k):\n # print (len(groups[i]))\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\n f.write(\"Grupa %d:\\n\" % (i+1))\n for j in range(len(groups[i])):\n f.write(groups[i][j][0] + \" %.2lf\\n\" % groups[i][j][1])\n if i < k-1:\n f.write(\"--\\n\")\n\n with open(out_path + \"/em-all.dat\", \"a\") as f:\n f.write(\"K = %d\\n\" % k)\n for i in range(k):\n f.write(\"c%d:\" % (i+1))\n for j in range(dimension):\n f.write(\" %.2lf\" % centers[i][0][j])\n f.write(\"\\n\")\n f.write(\"grupa %d: %d primjera\\n\" % ((i+1), group_count[i]))\n f.write(\"#iter: %d\\n\" % num_iter)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n if k < 5:\n f.write(\"--\\n\")\n elif not out_iterations:\n with open(out_path + \"/em-konf.dat\", \"a\") as f:\n f.write(\"Konfiguracija %d:\\n\" % conf_num)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n f.write(\"#iteracija: %d\\n\" % num_iter)\n if out_minus == True:\n f.write(\"--\\n\")\n # if i < k - 1:\n else:\n iter_out.write(\"--\\n\")\n for i in range(len(group_dicts)):\n iter_out.write(\"Grupa %d:\" % (i+1))\n buff = \"\"\n for key in group_dicts[i]:\n buff += \" \" + key + \" %d\" % group_dicts[i][key] + \",\"\n\n buff = buff[:-1]\n iter_out.write(buff + \"\\n\")\n # pass","def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\n # Get initial centers\n n_samples, n_features = len(X), 2\n init_ids = _get_init_centers(n_clusters, X)\n if verbose:\n print('Initial centers are: {}'.format(init_ids))\n centers = init_ids\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\n cc, swapped = 0, True\n while True:\n swapped = False\n for i in range(n_samples):\n if i not in centers:\n for j in range(len(centers)):\n centers_ = deepcopy(centers)\n centers_[j] = i\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\n if tot_cost_ < tot_cost:\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\n centers = centers_\n swapped = True\n if verbose:\n print('Change centers to {}'.format(centers))\n if cc > max_iter:\n if verbose:\n print('End Searching by reaching maximum iteration')\n break\n if not swapped:\n if verbose:\n print('End Searching by no swaps')\n break\n cc += 1\n return centers, members, costs, tot_cost, dist_mat","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def run(\n self,\n number_of_clusters=None,\n max_K=8,\n method_clustering=\"pam\",\n init_clustering=\"random\",\n max_iter_clustering=100,\n discart_value_JI=0.6,\n bootstraps_JI=100,\n bootstraps_p_value=100,\n n_jobs=1,\n verbose=1,\n ):\n\n if number_of_clusters is None:\n self.k = optimizer.optimizeK(\n self.distance_matrix,\n self.y.to_numpy(),\n self.model_type,\n max_K,\n method_clustering,\n init_clustering,\n max_iter_clustering,\n discart_value_JI,\n bootstraps_JI,\n self.random_state,\n n_jobs,\n verbose,\n )\n\n if self.k == 1:\n warnings.warn(\"No stable clusters were found!\")\n return\n\n print(f\"Optimal number of cluster is: {self.k}\")\n\n else:\n self.k = number_of_clusters\n print(f\"Use {self.k} as number of cluster\")\n\n self.cluster_labels = (\n kmedoids.KMedoids(\n n_clusters=self.k,\n method=method_clustering,\n init=init_clustering,\n metric=\"precomputed\",\n max_iter=max_iter_clustering,\n random_state=self.random_state,\n )\n .fit(self.distance_matrix)\n .labels_\n )\n\n (\n self._data_clustering_ranked,\n self.p_value_of_features,\n ) = stats.calculate_global_feature_importance(\n self.X, self.y, self.cluster_labels, self.model_type\n )\n self._p_value_of_features_per_cluster = (\n stats.calculate_local_feature_importance(\n self._data_clustering_ranked, bootstraps_p_value\n )\n )","def k_means(data, k, max_iterations=100):\n if len(data) < k:\n raise ValueError('must have more data points than centers, got: {}'.format(len(data)))\n\n dim = 1 if len(np.shape(data)) == 1 else np.shape(data)[-1]\n means = np.empty((k, dim))\n\n # initialize means to random points in dataset\n taken = set()\n for kidx in range(k):\n rand_idx = np.random.randint(len(data))\n while rand_idx in taken:\n rand_idx = np.random.randint(len(data))\n taken.add(rand_idx)\n means[kidx, :] = data[rand_idx, :]\n\n prev_assignments = []\n assignments = []\n for idx in range(max_iterations):\n\n # check for convergence\n if prev_assignments != [] and prev_assignments == assignments:\n break\n\n # reset assignments\n prev_assignments = assignments\n assignments = []\n\n # assign to means\n for sample in data:\n min_k_idx = 0\n min_k_dist = utils.euclidean_dist(means[0], sample)\n for kidx in range(1, k):\n k_dist = utils.euclidean_dist(means[kidx], sample)\n if k_dist < min_k_dist:\n min_k_dist = k_dist\n min_k_idx = kidx\n assignments.append(min_k_idx)\n\n # show intermediate cluster assignments\n # utils.plot_1d_data_assigments(data, means, assignments)\n\n # recompute means\n means = np.zeros((k, dim))\n mean_counts = collections.defaultdict(int)\n for sample, kidx in zip(data, assignments):\n means[kidx, :] += sample\n mean_counts[kidx] += 1\n \n for kidx, count in mean_counts.iteritems():\n means[kidx] /= float(count)\n \n return means, assignments","def KMeans(dataTable, k, epsilon=0.00001, srcDims = 1000000000000000, iters=20, normData = False):\n #load up the configuration\n kmOptions = KMeansConfig(dataTable,k,epsilon,srcDims)\n \n \n #load and format the table for use.\n data = loadMatrix(dataTable)[:,:kmOptions['sourceDims']]\n \n #check if we should normalise the data (this is really quick and dirty, replace it with something better)\n if normData:\n dmax = amax(data)\n dmin = amin(data)\n data = (data-dmin)/(dmax-dmin+0.00000001)\n \n \n #make our starting point solutions from the dataset\n solutions = [array(random.sample(data,k)) for i in xrange(iters)]\n \n #chunk solutions if necessary\n for i in xrange(len(solutions)):\n sol = []\n while len(solutions[i]) > kmOptions['chunkSize']:\n sol.append(solutions[i][:kmOptions['chunkSize']])\n solutions[i] = solutions[i][kmOptions['chunkSize']:]\n sol.append(solutions[i])\n solutions[i] = sol\n \n #create our chunked problem data\n dataChunks = []\n while len(data) > kmOptions['chunkSize']:\n dataChunks.append(data[:kmOptions['chunkSize']])\n data = data[kmOptions['chunkSize']:]\n dataChunks.append(data)\n kNorm = (len(dataChunks)-1)+len(dataChunks[-1])/float(len(dataChunks[0]))\n \n #create the CUDA kernels\n program = SourceModule(open(KernelLocation+\"KMEANS_LABEL.nvcc\").read())\n prg = program.get_function(\"KMEANS_LABEL\")\n program = SourceModule(open(KernelLocation+\"KMEANS_UPDATE.nvcc\").read())\n prg2 = program.get_function(\"KMEANS_UPDATE\")\n t0 = time.time()\n \n #store the resultant performance of each solution here\n results = []\n finalSols = []\n \n #make GPU allocations and support variables\n total = 0.\n dists = [numpy.zeros(kmOptions['chunkSize']).astype(numpy.float32)+10000000000000000. for i in xrange(len(dataChunks))] #this is used as an intermediate step\n labels = [numpy.zeros(kmOptions['chunkSize']).astype(numpy.uint32) for i in xrange(len(dataChunks))] #this is used as an intermediate step\n data_gpu = drv.mem_alloc(dataChunks[0].nbytes)\n k_gpu = drv.mem_alloc(solutions[0][0].nbytes)\n labels_gpu = drv.mem_alloc(labels[0].nbytes)\n dists_gpu = drv.mem_alloc(dists[0].nbytes)\n \n #calculate KMeans\n for sol in solutions:\n t0 = time.time()\n for i in xrange(10000):\n #Step 1: find all the closest labels\n for i in xrange(len(sol)):\n #copy in blank distances, labels, and the label coordinates\n drv.memcpy_htod(k_gpu, sol[i])\n for j in xrange(len(dataChunks)):\n drv.memcpy_htod(data_gpu, dataChunks[j])\n drv.memcpy_htod(labels_gpu, labels[j])\n drv.memcpy_htod(dists_gpu, dists[j])\n prg(k_gpu,\n data_gpu,\n kmOptions[\"dimensions\"],\n labels_gpu,\n dists_gpu,\n kmOptions['k'],\n kmOptions['dataSize'],\n kmOptions['chunkSize'],\n numpy.int64(i*kmOptions['chunkSize']), #k offset\n numpy.int64(j*kmOptions['chunkSize']), #data offset\n kmOptions['maxThreads'],\n block=kmOptions['block'],\n grid=kmOptions['grid'])\n drv.memcpy_dtoh(labels[i], labels_gpu)\n #Step 2: find the new averages\n old_sol = [s.copy() for s in sol]\n for i in xrange(len(sol)):\n #load up a blank set of k matrices\n drv.memcpy_htod(k_gpu, sol[i]*0.)\n for j in xrange(len(dataChunks)):\n drv.memcpy_htod(data_gpu, dataChunks[j])\n drv.memcpy_htod(labels_gpu, labels[j])\n prg2(k_gpu,\n data_gpu,\n kmOptions[\"dimensions\"],\n labels_gpu,\n kmOptions['k'],\n kmOptions['dataSize'],\n kmOptions['chunkSize'],\n numpy.int64(i*kmOptions['chunkSize']), #label offset\n numpy.int64(j*kmOptions['chunkSize']), #data offset\n kmOptions['maxThreads'],\n block=kmOptions['block'],\n grid=kmOptions['grid'])\n drv.memcpy_dtoh(sol[i], k_gpu)\n sol[i] /= kNorm #final normalisation\n #Step 3: check that the update distance is larger than epsilon\n total = 0.\n for j in xrange(len(sol)):\n tmp = sol[j]-old_sol[j]\n tmp = tmp*tmp\n total += sum([sum(t**0.5) for t in tmp])\n if total/kmOptions['dataSize'] < kmOptions['eps']:\n break\n print \"solution done in \",time.time()-t0\n results.append((total,len(results)))\n finalSols.append(numpy.concatenate(sol)[:kmOptions['dataSize']])\n results.sort()\n return finalSols[results[0][1]]","def kmeans_clustering(proj_df, k):\r\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\r\n k_means.fit(proj_df)\r\n labels= k_means.predict(proj_df)\r\n \r\n return labels","def naive_sharding(self, ds, k):\n\n n = np.shape(ds)[1]\n m = np.shape(ds)[0]\n centroids = np.mat(np.zeros((k,n)))\n\n # Sum all elements of each row, add as col to original dataset, sort\n composite = np.mat(np.sum(ds, axis=1))\n ds = np.append(composite.T, ds, axis=1)\n ds.sort(axis=0)\n\n # Step value for dataset sharding\n step = floor(m/k)\n\n # Vectorize mean ufunc for numpy array\n vfunc = np.vectorize(self._get_mean)\n\n # Divide matrix rows equally by k-1 (so that there are k matrix shards)\n # Sum columns of shards, get means; these column means are centroids\n for j in range(k):\n if j == k-1:\n centroids[j:] = vfunc(np.sum(ds[j*step:,1:], axis=0), step)\n else:\n centroids[j:] = vfunc(np.sum(ds[j*step:(j+1)*step,1:], axis=0), step)\n\n return centroids","def assignment(self, addresses, centroids, k):\n newClusters = {}\n print centroids\n for (lat, long) in addresses:\n minDistance = float('Inf')\n minIndex = 0\n for i in range(k):\n if pow(self.euclideanDistance((lat, long), centroids[i]),2) < minDistance:\n minDistance = pow(self.euclideanDistance((lat, long), centroids[i]),2)\n minIndex = i\n if minIndex in newClusters:\n newClusters[minIndex].append((lat, long))\n else:\n newClusters[minIndex] = [(lat, long)]\n return newClusters","def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\r\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\r\n\r\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\r\n #loop through first element separately so that subsequent values can be appended\r\n node_cluster_set_test_str, ds_arr = [], []\r\n for prec in prec_vals:\r\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\r\n for clus in node_cluster_set_test_str_app:\r\n #add cluster to cluster set\r\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\r\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\r\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\r\n clus_num_arr.append(node_num)\r\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\r\n prec_arr.append(prec)\r\n recall_arr.append(recall)\r\n F1_arr.append(F1)\r\n\r\n return clus_num_arr, prec_arr, recall_arr, F1_arr","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def get_clusters(self,points):\n self.points = points\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\n ##self.hull = \n return self.__dabest","def kmeans(X, k, iterations=1000):\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\n return None, None\n if not isinstance(k, int) or k <= 0:\n return None, None\n if not isinstance(iterations, int) or iterations <= 0:\n return None, None\n n, d = X.shape\n X_min = X.min(axis=0)\n X_max = X.max(axis=0)\n C = np.random.uniform(X_min, X_max, size=(k, d))\n\n for i in range(iterations):\n centroids = np.copy(C)\n centroids_extended = C[:, np.newaxis]\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\n clss = np.argmin(distances, axis=0)\n for c in range(k):\n if X[clss == c].size == 0:\n C[c] = np.random.uniform(X_min, X_max, size=(1, d))\n else:\n C[c] = X[clss == c].mean(axis=0)\n\n centroids_extended = C[:, np.newaxis]\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\n clss = np.argmin(distances, axis=0)\n\n if (centroids == C).all():\n break\n\n return C, clss","def lloyds_algorithm(X, k, T):\n n, d = X.shape\n\n # Initialize clusters random.\n clustering = np.random.randint(0, k, (n,))\n centroids = np.zeros((k, d))\n\n # Used to stop if cost isn't improving (decreasing)\n cost = 0\n oldcost = 0\n\n # Column names\n # print(\"Iterations\\tCost\")\n for i in range(T):\n\n # Update centroid\n centroids = np.zeros((k, d))\n # YOUR CODE HERE\n numberOfPointsInClusters = np.zeros((k,))\n for idx, point in enumerate(clustering):\n numberOfPointsInClusters[point] += 1\n centroids[point] += X[idx]\n for n in range(k):\n if numberOfPointsInClusters[n] == 0:\n numberOfPointsInClusters[n] = float('-inf')\n centroids = [centroid / numberOfPointsInClusters[idx] for idx, centroid in enumerate(centroids)]\n # END CODE\n\n # Update clustering\n\n # YOUR CODE HERE\n for idx, point in enumerate(X):\n clustering[idx] = np.argmin([np.linalg.norm(point - cluster) for cluster in centroids])\n # END CODE\n\n # Compute and print cost\n cost = 0\n for j in range(n):\n cost += np.linalg.norm(X[j] - centroids[clustering[j]]) ** 2\n # print(i + 1, \"\\t\\t\", cost)\n\n # Stop if cost didn't improve more than epislon (decrease)\n if np.isclose(cost, oldcost): break # TODO\n oldcost = cost\n\n return clustering, centroids, cost","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\n res = []\n for n_clusters in n_clusters_considered:\n res.append([])\n for _ in range(n_repeats):\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\n print(X.val.shape)\n print(X_restricted.val.shape)\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\n res[-1].append(evaluator_X.weighted_average) \n return res","def run(self, points, K):\n # Get size\n D, N = points.shape\n\n # DxK array initialiezd with random points\n centroids = points[:, np.random.permutation(N)[:K]]\n\n # Assigments 1xN array\n labels = np.zeros(N)\n\n for it in np.arange(self.niter):\n # 1. Compute distance to all cluster\n #v1 dirty\n distances = np.zeros([K, N])\n for n in np.arange(N):\n for k in np.arange(K):\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \n\n # 2. Update assigments\n # v1 dirty\n for n in np.arange(N):\n kmin = 0\n for k in np.arange(1, K):\n if distances[k, n] <= distances[kmin, n]:\n kmin = k\n labels[n] = kmin\n # v2 quicker\n #labels = np.argmin(distances, axis=1)\n\n # 3. Update mean\n for k in np.arange(K):\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\n\n return centroids, labels","def test_example(self): \n num_clusters = 2\n iterations = 5\n ts1 = 2.5 * np.random.randn(100,) + 3\n X_1 = pd.Series(ts1)\n ts2 = 2 * np.random.randn(100,) + 5\n X_2 = pd.Series(ts2)\n ts3 = -2.5 * np.random.randn(100,) + 3\n X_3 = pd.Series(ts3)\n list_of_series = [X_1, X_2, X_3]\n from pynuTS.clustering import DTWKmeans\n clts = DTWKmeans(num_clust = num_clusters, num_iter = iterations)\n clts.fit(list_of_series)\n ts4 = 3.5 * np.random.randn(100,) + 2\n ts5 = -3.5 * np.random.randn(100,) + 2\n X_4 = pd.Series(ts4)\n X_5 = pd.Series(ts5)\n list_new = [X_4, X_5]\n clustering_dict = clts.predict(list_new)\n\n assert type(clustering_dict) is dict\n assert len(clustering_dict) == num_clusters","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def _cluster(self):\n self._not_included = self.data\n self.leaves = []\n flag = int(rand() * len(self.data))\n flag = self._generate(flag)\n while len(self._not_included) > 0:\n flag = self._generate(flag)\n if flag == -1:\n break\n pass\n self._remember.append({\n 'threshold': self._base_threshold,\n 'result': len(self.leaves)\n })\n print(len(self._remember), {\n 'threshold': self._base_threshold,\n 'result': len(self.leaves)\n })\n return","def splitCluster(self, cluster):\n\t\tmaxValue = self.getMaxValue(self.clusterList[cluster])\n\t\tminValue = self.getMinValue(self.clusterList[cluster])\n\t\tmidValue = round(maxValue - ((maxValue - minValue) / 2))\n\n\t\t# Create a set of centroid\n\t\tfirstCentroid = random.randint(minValue, midValue)\n\t\tsecondCentroid = random.randint(midValue, maxValue)\n\n\t\tcpyCluster = self.clusterList[cluster]\n\t\tnextName = str(len(self.clusterList))\n\t\tself.clusterList[cluster] = []\n\t\tself.clusterList[nextName] = []\n\n\t\tfor value in cpyCluster:\n\t\t\tif abs(value - firstCentroid) < abs(value - secondCentroid):\n\t\t\t\tself.clusterList[cluster].append(value)\n\t\t\telse:\n\t\t\t\tself.clusterList[nextName].append(value)\n\t\t\tpass\n\t\tpass\n\t\tprint(self.clusterList)","def generate_clusters(self, medoids, samples):\n clusters = []\n for i in range(0, medoids.shape[0]):\n clusters.append([])\n for currentSampleIndex in range(0, samples.shape[0]):\n currentSample = samples[currentSampleIndex]\n minDistance = np.inf\n minDistanceIndex = 0\n for currentMedoidIndex in range(0, medoids.shape[0]):\n currentDistance = distance.euclidean(currentSample, medoids[currentMedoidIndex])\n if (currentDistance < minDistance):\n minDistance = currentDistance\n minDistanceIndex = currentMedoidIndex\n clusters[minDistanceIndex].append(currentSample)\n return clusters\n pass","def calc_final_clusters(sp_initial, km_initial):\r\n sp_final = kc.kmeans(T.tolist(), sp_initial, k, n, k, MAX_ITER)\r\n km_final = kc.kmeans(data.tolist(), km_initial, k, n, d, MAX_ITER)\r\n if km_final is None or sp_final is None:\r\n exit(1)\r\n spectral_clusters = np.array(sp_final)\r\n kmeans_clusters = np.array(km_final)\r\n\r\n return spectral_clusters, kmeans_clusters"],"string":"[\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def generate_k(data_set, k):\\n centers = []\\n dimensions = len(data_set[0])\\n min_max = defaultdict(int)\\n\\n for point in data_set:\\n for i in range(dimensions):\\n val = point[i]\\n min_key = 'min_{0}d'.format(i)\\n max_key = 'max_{0}d'.format(i)\\n if min_key not in min_max or val < min_max[min_key]:\\n min_max[min_key] = val\\n if max_key not in min_max or val > min_max[max_key]:\\n min_max[max_key] = val\\n\\n for _k in range(k):\\n rand_point = []\\n for i in range(dimensions):\\n min_val = min_max['min_{0}d'.format(i)]\\n max_val = min_max['max_{0}d'.format(i)]\\n \\n rand_point.append(uniform(min_val, max_val))\\n centers.append(rand_point)\\n return centers\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def kMeans(d, k):\\n #First get the random centroids from the data\\n newCentroids = getRandomCentroids(d, k)\\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\\n\\n #Get the clusters from these random centroids\\n clusters = initiateCentroid(d, newCentroids, k)\\n oldCentroids = []\\n\\n counter = 0\\n #While the old centroids are not equal to the new ones\\n while oldCentroids != newCentroids:\\n #old is equal to new\\n oldCentroids = newCentroids\\n #Calculate the new centroids\\n k, newCentroids = calcCentroids(d, clusters)\\n #Calculate the new clusters\\n clusters = initiateCentroid(d, newCentroids, k)\\n #Count how many iterations\\n counter += 1\\n\\n return counter, clusters\",\n \"def optimalK(data, nrefs=3, maxClusters=15):\\r\\n gaps = np.zeros((len(range(1, maxClusters)),))\\r\\n resultsdf = pd.DataFrame({'clusterCount':[], 'gap':[]})\\r\\n for gap_index, k in enumerate(range(1, maxClusters)):\\r\\n\\r\\n # Holder for reference dispersion results\\r\\n refDisps = np.zeros(nrefs)\\r\\n\\r\\n # For n references, generate random sample and perform kmeans getting resulting dispersion of each loop\\r\\n for i in range(nrefs):\\r\\n\\r\\n # Create new random reference set\\r\\n randomReference = np.random.random_sample(size=data.shape)\\r\\n\\r\\n # Fit to it\\r\\n km = KMeans(k)\\r\\n km.fit(randomReference)\\r\\n\\r\\n refDisp = km.inertia_\\r\\n refDisps[i] = refDisp\\r\\n\\r\\n # Fit cluster to original data and create dispersion\\r\\n km = KMeans(k)\\r\\n km.fit(data)\\r\\n print(k)\\r\\n\\r\\n origDisp = km.inertia_\\r\\n\\r\\n # Calculate gap statistic\\r\\n gap = np.log(np.mean(refDisps)) - np.log(origDisp)\\r\\n\\r\\n # Assign this loop's gap statistic to gaps\\r\\n gaps[gap_index] = gap\\r\\n\\r\\n resultsdf = resultsdf.append({'clusterCount':k, 'gap':gap}, ignore_index=True)\\r\\n\\r\\n\\r\\n return (gaps.argmax() + 1, resultsdf) # Plus 1 because index of 0 means 1 cluster is optimal, index 2 = 3 clusters are optimal\\r\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def __generate_central_nodes(self,k=3):\\n if k < 3:\\n k = 3\\n \\n self.__logger.info(\\\"CENTRAL_NODES: Try to seek {} nodes which are currently central\\\".format(k)) \\n res = [n for n,_ in sorted(nx.betweenness_centrality(self.G).items(),key=itemgetter(1),reverse=True)[:4*k]]\\n self.__logger.info(\\\"CENTRAL_NODES: Generated top {} central nodes (according to betweeness centrality)\\\".format(len(res)))\\n \\n self.__logger.info(\\\"CENTRAL_NODES: Sample {} items from the candidates as was requested\\\".format(k))\\n tmp = list(res)\\n random.shuffle(tmp)\\n return tmp[0:k]\",\n \"def generate_clusters(df):\\n\\n df_size = df.shape[0]\\n print(df_size)\\n n_clusters = 0\\n percent_min_pts = 0.105\\n min_clusters = 3\\n while (n_clusters != min_clusters):\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n min_cluster_pts = math.floor(df_size * percent_min_pts)\\n print(\\\"min_cluster_pts\\\", min_cluster_pts)\\n\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\\n print(df.head())\\n clusterer.fit(df)\\n cluster_groups = {}\\n labels = clusterer.labels_\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n n_clusters = len(set(labels))\\n print(\\\"n_clusters\\\", n_clusters)\\n multiplier = abs(n_clusters - min_clusters) * 0.001\\n print(\\\"multiplier\\\", multiplier)\\n if n_clusters > min_clusters:\\n percent_min_pts += multiplier\\n else:\\n percent_min_pts -= multiplier\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n return labels\",\n \"def create_cluster(df,validate, test, X, k, name):\\n \\n scaler = StandardScaler(copy=True).fit(df[X])\\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\\n kmeans = KMeans(n_clusters = k, random_state = 42)\\n kmeans.fit(X_scaled)\\n kmeans.predict(X_scaled)\\n df[name] = kmeans.predict(X_scaled)\\n df[name] = 'cluster_' + df[name].astype(str)\\n \\n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\\n validate[name] = kmeans.predict(v_scaled)\\n validate[name] = 'cluster_' + validate[name].astype(str)\\n \\n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\\n test[name] = kmeans.predict(t_scaled)\\n test[name] = 'cluster_' + test[name].astype(str)\\n \\n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\\n return df, X_scaled, scaler, kmeans, centroids\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def cluster(self, k=3, max_iter=10):\\n\\n # create a set of k random clusters as seeds\\n old_clusters = [None] * k # just a placeholder\\n clusters = self.random_clusters(k)\\n\\n iter = 0\\n while (iter < max_iter) and not (old_clusters == clusters):\\n print \\\"iteration %d...\\\" % iter\\n # assign new clusters to old clusters\\n for i in xrange(0, k):\\n old_clusters[i] = copy(clusters[i])\\n clusters[i].documents = []\\n\\n # for each document\\n for document in self.documents:\\n\\n # determine the cluster with the highest similarity\\n similarities = [cosine_similarity(document, cluster) for cluster in old_clusters]\\n max_index = array(similarities).argmax()\\n\\n # assign document to that cluster\\n clusters[max_index].add(document)\\n\\n # update cluster means\\n for cluster in clusters:\\n cluster.update_centroid()\\n \\n iter += 1\\n \\n return clusters\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def _create_constrained_dataset(centers, delta, size):\\n dataset = []\\n count = 0\\n for i, c in enumerate(centers):\\n for j in range(size):\\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\\n direction = x / np.linalg.norm(x)\\n magnitude = np.random.uniform(0.0, 0.5 * delta)\\n # magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED\\n dataset.append((c + magnitude * direction, i, count))\\n count += 1\\n return dataset\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def generate_clusterarray(k_cluster, cluster_size):\\n result = np.zeros(k_cluster + 1, dtype = np.int32)\\n for i in range(1,len(result)):\\n result[i] = cluster_size\\n return result\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def eval_kd_cluster(kmers):\\n shuffle(kmers)\\n search_set, kmers = kmers[:1000], kmers[1000:]\\n for H in [0.15, 0.125, 0.1, 0.075, 0.05]:\\n kdrft_cover = KDRFTCover(H)\\n\\n start = clock()\\n for kmer in kmers:\\n kdrft_cover.add(kmer)\\n kdrft_cover.greedy_clusters()\\n build_time = clock() - start\\n\\n stats = kdrft_cover.stats()\\n stats['build_time'] = build_time\\n stats['H'] = H\\n\\n start = clock()\\n for kmer in search_set:\\n kdrft_cover.search(kmer, 2)\\n stats['search_time'] = (clock() - start)\\n yield stats\",\n \"def generate_clusters_n(df, tweet_deleted):\\n # cluster_labels, n_clusters = dbscan(normalised_df, true_labels, 0.25, 30)\\n # print(\\\"normalised_df.head()\\\", normalised_df.head())\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=10)\\n clusterer.fit(df)\\n labels = clusterer.labels_\\n cluster_groups = {}\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n df[\\\"cluster\\\"] = labels\\n df[\\\"tweet_deleted\\\"] = tweet_deleted\\n cluster_results = list()\\n for cluster_no in cluster_groups.keys():\\n print(\\\"++++++++++\\\")\\n print(\\\"cluster_no\\\", cluster_no)\\n cluster_result = list()\\n cluster_result.append(cluster_no)\\n\\n cluster = df.mask('cluster', cluster_no)\\n print(cluster_no, \\\" :\\\")\\n tweet_deleted = cluster.mask('tweet_deleted', True).shape[0]\\n not_tweet_deleted = cluster.mask('tweet_deleted', False).shape[0]\\n print(\\\"deleted_df len:\\\", tweet_deleted)\\n print(\\\"not_deleted_df len:\\\", not_tweet_deleted)\",\n \"def determine_k(dataset, range_k, n_seed=30):\\r\\n range_Ks = np.arange(0,range_k,1,dtype=int) #range of delays to study\\r\\n h_K=np.zeros((10,range_k))\\r\\n \\r\\n for i in range(10):\\r\\n for k, K in enumerate(range_Ks):\\r\\n traj_matrix= embed.trajectory_matrix(dataset, K=K)\\r\\n labels= cl.kmeans_knn_partition(traj_matrix, n_seed)\\r\\n h= op_calc.get_entropy(labels)\\r\\n h_K[i,k]=h\\r\\n \\r\\n return(h_K)\",\n \"def distortion_of_kmeans_clustering(data_table):\\n num_iritations = 5\\n singleton_list = []\\n for line in data_table:\\n singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\\n distortion_list = []\\n for num in range(20, 5, -1):\\n cluster_list = kmeans_clustering(singleton_list,num, num_iritations)\\n distortion = compute_distortion(data_table, cluster_list)\\n distortion_list.append(distortion)\\n return distortion_list\\n\\n#####################################################################\\n# Code to load cancer data, compute a clustering and\\n# visualize the results\\n\\n\\n# def run_example():\\n# \\\"\\\"\\\"\\n# Load a data table, compute a list of clusters and\\n# plot a list of clusters\\n#\\n# Set DESKTOP = True/False to use either matplotlib or simplegui\\n# \\\"\\\"\\\"\\n# data_table = load_data_table(DATA_3108_URL)\\n# singleton_list = []\\n# for line in data_table:\\n# singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\\n num_clusters = 16\\n # cluster_list = sequential_clustering(singleton_list, num_clusters)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"sequential clusters\\\")\\n #\\n # cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, num_clusters)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"hierarchical clusters\\\")\\n #\\n # cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, num_clusters, 5)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"k-means clusters\\\")\\n\\n # draw the clusters using matplotlib or simplegui\\n #\\n # if DESKTOP:\\n # # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, False)\\n # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, True) #add cluster centers\\n\\n # else:\\n # alg_clusters_simplegui.PlotClusters(data_table, cluster_list) # use toggle in GUI to add cluster centers\",\n \"def hierarchical_clustering(cluster_list, num_clusters):\\n # n <-- |P|\\n len_cluster_list = len(cluster_list)\\n \\n # Initialize n clusters C = {C1, ... Cn} such that Ci = {pi};\\n new_cluster_list = []\\n\\n for index in range(len_cluster_list):\\n new_cluster_list.append(alg_cluster.Cluster(cluster_list[index].fips_codes(), cluster_list[index].horiz_center(), cluster_list[index].vert_center(), cluster_list[index].total_population(), cluster_list[index].averaged_risk()))\\n\\n # while |C| > k do\\n while len(new_cluster_list) > num_clusters:\\n # (Ci,Cj) <-- argminCi,Cj Element C, i != j^dCi,Cj;\\n # C <-- C Union {Ci Union Cj}; // line 5\\n # C <-- C \\\\ {Ci, Cj}; // line 6\\n fc_pair = fast_closest_pair(new_cluster_list)\\n # print \\\"\\\\nfc_pair:\\\", fc_pair, \\\"\\\\n\\\"\\n new_cluster_list[fc_pair[1]].merge_clusters(new_cluster_list[fc_pair[2]])\\n del new_cluster_list[fc_pair[2]]\\n\\n return new_cluster_list\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n\\n # Scale the data so that Euclidian distance makes sense\\n means = np.mean(data, axis = 0)\\n stddevs = np.std(data, axis = 0, ddof = 1)\\n\\n #print(means)\\n #print(stddevs)\\n\\n data_scaled = np.zeros((n_examples, n_features))\\n\\n for i in range(n_features):\\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\\n\\n study_correlation(data_scaled)\\n\\n # Initialize the centroids\\n idx = np.random.randint(n_examples, size = n_clusters)\\n centroids = data_scaled[idx, :]\\n\\n counter = 0\\n\\n while True:\\n\\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\\n centroid_idx = np.argmin(distances, axis = 1)\\n old_centroids = centroids\\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\\n #displacement = get_displacement(old_centroids, centroids)\\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\\n\\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\\n\\n if counter == 0:\\n# print(\\\"Initial displacement = {}\\\".format(displacement))\\n initial_displacement = displacement\\n\\n counter += 1\\n\\n if displacement < (initial_displacement / 10000): break\\n\\n #print(\\\"Total number of loops before ending : {}\\\".format(counter))\\n converted_predictions = convert_predictions(centroid_idx)\\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def cluster_dpc_knn(token_dict, cluster_num, k=5, token_mask=None):\\n with torch.no_grad():\\n x = token_dict['x']\\n B, N, C = x.shape\\n dist_matrix = torch.cdist(x, x) / C ** 0.5\\n if token_mask is not None:\\n token_mask = token_mask > 0\\n dist_matrix = dist_matrix * token_mask[:, None, :] + (dist_matrix.max() + 1) * ~token_mask[:, None, :]\\n dist_nearest, index_nearest = torch.topk(dist_matrix, k=k, dim=-1, largest=False)\\n density = (-(dist_nearest ** 2).mean(dim=-1)).exp()\\n density = density + torch.rand(density.shape, device=density.device, dtype=density.dtype) * 1e-06\\n if token_mask is not None:\\n density = density * token_mask\\n mask = density[:, None, :] > density[:, :, None]\\n mask = mask.type(x.dtype)\\n dist_max = dist_matrix.flatten(1).max(dim=-1)[0][:, None, None]\\n dist, index_parent = (dist_matrix * mask + dist_max * (1 - mask)).min(dim=-1)\\n score = dist * density\\n _, index_down = torch.topk(score, k=cluster_num, dim=-1)\\n dist_matrix = index_points(dist_matrix, index_down)\\n idx_cluster = dist_matrix.argmin(dim=1)\\n idx_batch = torch.arange(B, device=x.device)[:, None].expand(B, cluster_num)\\n idx_tmp = torch.arange(cluster_num, device=x.device)[None, :].expand(B, cluster_num)\\n idx_cluster[idx_batch.reshape(-1), index_down.reshape(-1)] = idx_tmp.reshape(-1)\\n return idx_cluster, cluster_num\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def diameter_clustering_vs_prob_ws(num_nodes, k):\\r\\n xdata = []\\r\\n ydata = []\\r\\n zdata = []\\r\\n prob = 0.0005\\r\\n while prob < 1:\\r\\n xdata += [prob]\\r\\n diameters = []\\r\\n coeffs = []\\r\\n for i in range(k):\\r\\n graph = make_ws_graph(num_nodes, 8, prob)\\r\\n diameters += [diameter(graph)]\\r\\n coeffs += [clustering_coefficient(graph)]\\r\\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\\r\\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\\r\\n prob = 1.2*prob\\r\\n return xdata, ydata, zdata\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\ttotal_clusters = len(cluster_list)\\n\\tclusters = sorted(cluster_list, key = lambda cluster: \\\\\\n\\t\\t\\t\\t\\t cluster.total_population(), reverse = True)\\n\\tk_clusters = clusters[:num_clusters]\\n\\tfor dummy_idx_i in range(num_iterations):\\n\\t\\tk_empties = [Cluster(set([]), 0, 0, 0, 0) for \\\\\\n\\t\\t\\t\\t\\t dummy_idx in range(num_clusters)]\\n\\t\\tfor idx_j in range(total_clusters):\\n\\t\\t\\tdist = [cluster_list[idx_j].distance(k_clusters[idx_f]) for \\\\\\n\\t\\t\\t\\t\\tidx_f in range(num_clusters)]\\n\\t\\t\\tidx_l = dist.index(min(dist))\\n\\t\\t\\tk_empties[idx_l].merge_clusters(cluster_list[idx_j])\\n\\t\\tk_clusters = k_empties[:]\\n\\treturn k_clusters\",\n \"def kmeans_clustering(self,k):\\r\\n \\r\\n print(colored(\\\"Performing K-means clustering with %d clusters\\\\n\\\"%k,color = 'yellow', attrs=['bold']))\\r\\n kmeans = KMeans(n_clusters=k, random_state=0, n_init=10, max_iter=100, n_jobs=-1, ).fit(self.X)\\r\\n self.labels = kmeans.labels_\\r\\n self.davies_bouldin_score()\\r\\n print()\\r\\n print(colored(\\\"The k-means inertia is %0.002f\\\\n\\\" %(kmeans.inertia_),color = 'red', attrs=['bold']))\\r\\n self.cluster_plot()\\r\\n return self.labels , kmeans.cluster_centers_,kmeans\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\\n\\n # Your code here. You should also change the return value.\\n\\n def _initiate_random_centroids(all_features, vocab_size):\\n \\\"\\\"\\\"\\n Initiate random centroids in the range of input\\n\\n :param all_features:\\n :param vocab_size:\\n :return:\\n \\\"\\\"\\\"\\n centroids = []\\n # 1) Genereate points for initial centroids\\n\\n min_feat = np.ones(all_features[0].size)*np.inf\\n max_feat = np.zeros(all_features[0].size)\\n\\n for a in all_features:\\n for p in range(len(a)):\\n if a[p] < min_feat[p]:\\n min_feat[p] = a[p]\\n else:\\n if a[p] > max_feat[p]:\\n max_feat[p] = a[p]\\n\\n\\n for _ in range(vocab_size):\\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\\n max_feat-min_feat) + min_feat\\n centroids.append(random_vector.flatten())\\n\\n return np.array(centroids)\\n\\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\\n \\\"\\\"\\\"\\n Assign vectors to nearest centroids\\n\\n :param all_features:\\n :param centroid:\\n :return:\\n \\\"\\\"\\\"\\n #TODO: sprawdz co lepiej dziala\\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\\n #new_centroid_coor = centroid\\n new_centroid_counter = np.zeros(len(centroid))\\n\\n dist = pdist(centroid, all_features)\\n #min_dist = dist.min(axis=0)\\n min_dist_index = dist.argmin(axis=0)\\n\\n for x in range(len(min_dist_index)):\\n id = min_dist_index[x]\\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\\n all_features[x])\\n new_centroid_counter[id] += 1\\n\\n new_centroid_coor_out = []\\n for i in range(len(new_centroid_coor)):\\n if new_centroid_counter[i] == 0:\\n new_centroid_coor_out.append(centroid[i])\\n else:\\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\\n\\n return np.array(new_centroid_coor_out), new_centroid_counter\\n\\n\\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\\n \\\"\\\"\\\"\\n Check convergence confition\\n\\n :param old_centroids:\\n :param new_centroids:\\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\\n :return:\\n \\\"\\\"\\\"\\n for i in range(len(old_centroids)):\\n dist = euclidean(old_centroids[i], new_centroids[i])\\n if dist > epsilon:\\n return False\\n\\n return True\\n\\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\\n \\\"\\\"\\\"\\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\\n\\n :param new_centroids:\\n :param centroid_counter:\\n :param threshold:\\n :return:\\n \\\"\\\"\\\"\\n\\n out_centroids = []\\n for n in range(len(new_centroids)):\\n if centroid_counter[n] > threshold:\\n out_centroids.append(new_centroids[n])\\n out_centroids = np.array(out_centroids)\\n return out_centroids\\n\\n #MAIN\\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\\n\\n for _ in range(max_iter):\\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\\n\\n if if_convergenced == True:\\n # return centroids if algorithm is converged\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\\n old_centroids = new_centroids\\n\\n # return centroids if reached max_iter\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def cluster_kmeans(df, k):\\r\\n # Sample fron the original df\\r\\n sample_df=df.sample(n = k)\\r\\n obs, attr= df.shape\\r\\n # Make copies \\r\\n copy_df=df.copy()\\r\\n flag=0\\r\\n sse_old=0\\r\\n while (flag==0): \\r\\n sse=0\\r\\n Labels=[]\\r\\n for i in range(0, obs):\\r\\n dist= []\\r\\n for j in range(0,k):\\r\\n #Calculate Eucledian distance\\r\\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\\r\\n eu_dist=(sum(diff))**(1/attr)\\r\\n dist.append(eu_dist) \\r\\n #Add Labels to the observations based on the variable they are close to\\r\\n label=(dist.index(min(dist)))\\r\\n Labels.append(label)\\r\\n # Calculate SSE\\r\\n sse=sse+((min(dist) )**2)\\r\\n sse=sse**(1/2)\\r\\n copy_df['labels']=Labels\\r\\n # Stopping criteria is change in SSE should be 2 %\\r\\n if (sse_old !=0):\\r\\n if(abs(sse_old-sse)/sse_old<=0.05):\\r\\n flag=1 \\r\\n return_df=copy_df['labels'].to_frame()\\r\\n return (return_df, sse)\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n # Now pick random values from each label and add it to the sample df\\r\\n for val in range(0,k):\\r\\n #Create new sample df\\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n for val in range(0,k):\\r\\n #Create new sample df \\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\\r\\n ds_arr_ones = []\\r\\n for clus in SOM_clusters_block:\\r\\n node_cluster_set_test = [clus]\\r\\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\\r\\n #calculate the blocked days which the new cluster determines\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\\r\\n #calculate precision, recall and F1\\r\\n if len(str(node_cluster_set_test)) == 1:\\r\\n comb_str = f\\\"{node_cluster_set_test[0]}\\\".replace(\\\"'\\\", \\\"\\\")\\r\\n else:\\r\\n comb_str = f\\\"{str(node_cluster_set_test)[1:-1]}\\\".replace(\\\"'\\\", \\\"\\\") \\r\\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\\r\\n ds_arr_ones.append(ds)\\r\\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \\\"set\\\")\\r\\n return blocks_one_clusnum\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def clusterGen(k, colors):\\n clusters = []\\n # generate the clusters randomly\\n # for i in range(k):\\n # r = random.randint(0, 255)\\n # g = random.randint(0, 255)\\n # b = random.randint(0, 255)\\n # clusters.append((r, g, b))\\n\\n # generate the clusters that exist in colors\\n l = len(colors)\\n for i in range(k):\\n r = random.randint(0, l)\\n cluster = colors[r][1]\\n clusters.append(cluster)\\n\\n return clusters\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def private_center_recovery(\\n raw_data,\\n cluster_assignment,\\n norm,\\n epsilon,\\n delta,\\n):\\n\\n cluster_ids = np.unique(cluster_assignment)\\n _, d = raw_data.shape\\n centers = []\\n for _ in range(max(cluster_ids) + 1):\\n centers.append(np.zeros(d))\\n\\n for c_id in cluster_ids:\\n points = raw_data[c_id == cluster_assignment]\\n if np.size(points) == 0:\\n centers[c_id] = np.random.uniform(-norm, norm)\\n centers[c_id] = private_centers(points, norm, epsilon, delta)\\n return np.vstack(centers)\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def integrated_clustering(t_all,y_all,num_of_days=500,period = 1440,trim=10,min_n_clusters = 4, max_n_clusters=10,hierarchical=0):\\n\\n\\n\\n all_seg_april = initial_disaggregate(t_all,y_all,num_of_days,period = period)\\n \\n ''' '''\\n all_seg_april_normalized = [np.array(x[0])-np.mean(x[1]) for x in all_seg_april if len(x[1])==3]\\n \\n ''' filter the empty segments'''\\n all_seg_april_normalized = [x for x in all_seg_april_normalized if len(x)>0]\\n \\n ''' clustering in different ranges will probably have a better result'''\\n if hierarchical == 0:\\n pass\\n elif hierarchical ==1:\\n all_seg_april_normalized = [x for x in all_seg_april_normalized if x.mean()>1000]\\n else:\\n all_seg_april_normalized = [x for x in all_seg_april_normalized if x.mean()<1000]\\n \\n ''' filter out the positive segments'''\\n all_positive_seg_april_normalized = [x for x in all_seg_april_normalized if x.min()>0]\\n \\n \\n all_seg_april_normalized_trim50 = extract_first_n(all_positive_seg_april_normalized, trim)\\n cluster_average = []\\n \\n # find optimal clustering number using silhouette score\\n \\n optimal_dict = {}\\n \\n for n_clusters in range(min_n_clusters,max_n_clusters):\\n \\n y_pred = KMeans(n_clusters=n_clusters).fit_predict(all_seg_april_normalized_trim50)\\n\\n cluster_average = []\\n for i_cluster in range(n_clusters):\\n cluster_average.append(\\n np.mean([np.mean(x) for i, x in enumerate(all_seg_april_normalized_trim50) if y_pred[i]==i_cluster])\\n ) \\n\\n # sihouette score\\n cluster_labels = y_pred\\n sample_silhouette_values = silhouette_samples(all_seg_april_normalized_trim50, cluster_labels)\\n \\n silhouette_avg = silhouette_score(pd.DataFrame(all_seg_april_normalized_trim50), cluster_labels)\\n\\n optimal_dict[n_clusters] = silhouette_avg +(sample_silhouette_values.min()+sample_silhouette_values.max())/2\\n \\n # n_clusters will give us the optimal number of clusters\\n n_clusters = max(optimal_dict.iteritems(), key=operator.itemgetter(1))[0]\\n\\n #print n_clusters\\n \\n y_pred = KMeans(n_clusters=n_clusters).fit_predict(all_seg_april_normalized_trim50)\\n\\n cluster_average = []\\n \\n for i_cluster in range(n_clusters):\\n cluster_average.append(\\n np.mean([np.mean(x) for i, x in enumerate(all_seg_april_normalized_trim50) if y_pred[i]==i_cluster])\\n ) \\n cluster_average_rank = np.argsort(cluster_average)[::-1]\\n rank_map = {cluster_average_rank[i_cluster]:i_cluster for i_cluster in range(n_clusters)} # old index:new index\\n\\n y_pred_old = y_pred\\n y_pred = [rank_map[x] for x in y_pred]\\n all_seg_per_cluster = [[] for i in range(n_clusters) ]\\n for i_seg in range(len(all_seg_april_normalized_trim50)):\\n all_seg_per_cluster[y_pred[i_seg]].append(all_seg_april_normalized_trim50[i_seg])\\n \\n cluster_mean = [[] for i in range(n_clusters) ]\\n cluster_std = [[] for i in range(n_clusters) ]\\n for i_cluster in range(n_clusters):\\n cluster_mean[ i_cluster ] = np.mean(np.array(all_seg_per_cluster[i_cluster]), axis=0)\\n cluster_std[ i_cluster ] = np.std(np.array(all_seg_per_cluster[i_cluster]), axis=0)\\n \\n \\n \\n \\n #cluster_mean_2 = cluster_mean[5:6]\\n \\n return cluster_mean,cluster_std,n_clusters,all_seg_per_cluster\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def kmeans_fast(features, k, num_iters=100):\\n N = len(features)\\n print(N)\\n # Randomly initalize cluster centers\\n centers, assignments = np.array([features[i] for i in sorted(random.sample(range(0, len(features)), K))]), {}\\n _, dim = centers.shape\\n\\n tile_f = np.tile(features, (k, 1))\\n for n in range(num_iters):\\n tile_c = np.repeat(centers, N, axis=0)\\n tile_sub = np.subtract(tile_f, tile_c)\\n dist = np.linalg.norm(tile_sub, axis=1).reshape(k, N)\\n assignments_new = np.argmin(dist, axis=0)\\n if np.array_equal(assignments, assignments_new):\\n break\\n else:\\n assignments = assignments_new\\n\\n old_centers, new_stats = centers[:], []\\n for j in range(0, k):\\n new_stats.append([0, []])\\n for i in range(len(features)):\\n c_ind = int(assignments[i])\\n num, sum_vec = new_stats[c_ind]\\n sum_vec_new = np.add(sum_vec, features[i]) if len(sum_vec) > 0 else features[i]\\n new_stats[c_ind] = [num + 1, sum_vec_new]\\n\\n new_centers = np.zeros((k, dim))\\n for j in range(0, k):\\n num, new_center = new_stats[j]\\n new_center = np.divide(new_center, num)\\n new_centers[j] = np.array(new_center)\\n centers = new_centers\\n\\n return centers, assignments, 0\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def initiateCentroid(data_points, centroids, k):\\n #Create empty list in list (amount is k)\\n AvgCentroids = [[] for i in range(k)]\\n\\n #For each datapoint in all datapoints\\n for dp in data_points:\\n dis = []\\n #For each centroid in centroids\\n for c in range(len(centroids)):\\n #Calculate the euclidean distance between those points and append\\n #to distance list\\n dis.append(calcEuclideanDistance(dp, centroids[c]))\\n \\n #Get the smallest value of the list and the index\\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\\n\\n #The index of the smallest value is the index where it will be added\\n #to the avgCentroids list. So it represents the number of the cluster\\n AvgCentroids[idx].append(dp)\\n \\n return AvgCentroids\",\n \"def run_k_means(self):\\r\\n centroids = self.centroids\\r\\n\\r\\n for i in range(self.max_iters):\\r\\n self.closestcentroids()\\r\\n self.newcentroids()\\r\\n\\r\\n J = 0\\r\\n X = self.x\\r\\n m = len(X)\\r\\n idx = self.index\\r\\n K = self.K\\r\\n dim = X.shape[1]\\r\\n\\r\\n for num in range(K):\\r\\n # find the index of all entries where idx==n\\r\\n indexentries = np.nonzero(idx == num)[0]\\r\\n # the values in X that have the index in indesxentries\\r\\n values = X[indexentries]\\r\\n # using one of the K centroids to do the calculation. K<=2 doesn't\\r\\n # work here for some reason.\\r\\n centroid = centroids[num, 0]\\r\\n J += np.sum((values - centroid) ** 2)\\r\\n\\r\\n return [centroids.reshape((1, K, dim)), [X[idx == k].size for k in range(K)], J / m]\",\n \"def get_k_by_gap_statistic(data, nrefs=5):\\n\\n number_of_clusters = range(2, 15)\\n\\n gaps = np.zeros((len(number_of_clusters),))\\n\\n for gap_index, k in enumerate(number_of_clusters):\\n\\n # Holder for reference dispersion results\\n ref_disps = np.zeros(nrefs)\\n\\n # For n references, generate random sample and perform kmeans getting resulting dispersion of each loop\\n for i in range(nrefs):\\n # Create new random reference set\\n random_reference = np.random.random_sample(size=data.shape)\\n\\n # Fit to it\\n km = KMeans(n_clusters=k, init='k-means++', n_init=30,\\n precompute_distances=True, verbose=0, copy_x=True, n_jobs=-1)\\n km.fit(random_reference)\\n\\n ref_disp = km.inertia_\\n ref_disps[i] = ref_disp\\n\\n # Fit cluster to original data and create dispersion\\n km = KMeans(n_clusters=k, init='k-means++', n_init=30,\\n precompute_distances=True, verbose=0, copy_x=True, n_jobs=-1)\\n km.fit(data)\\n\\n orig_disp = km.inertia_\\n\\n # Calculate gap statistic\\n gap = np.log(np.mean(ref_disps)) - np.log(orig_disp)\\n\\n # Assign this loop's gap statistic to gaps\\n gaps[gap_index] = gap\\n\\n # Plus 1 because index of 0 means 1 cluster is optimal, index 2 = 3 clusters are optimal\\n return gaps.argmax() + 1\",\n \"def kmeans(self,mydata, k=None, centroids=None, steps=200):\\n\\t\\tif centroids is not None and k is not None:\\n\\t\\t\\tassert(k == len(centroids))\\n\\t\\telif centroids is not None:\\n\\t\\t\\tk = len(centroids)\\n\\t\\telif k is not None:\\n\\t\\t\\t# Forgy initialization method: choose k data points randomly.\\n\\t\\t\\tcentroids = mydata[np.random.choice(np.arange(len(mydata)), k, False)]\\n\\t\\telse:\\n\\t\\t\\traise RuntimeError(\\\"Need a value for k or centroids.\\\")\\n\\n\\t\\tfor _ in range(max(steps, 1)):\\n\\t\\t\\t# Squared distances between each point and each centroid.\\n\\t\\t\\tsqdists = scipy.spatial.distance.cdist(centroids, mydata, 'sqeuclidean')\\n\\n\\t\\t\\t# Index of the closest centroid to each data point.\\n\\t\\t\\tclusters = np.argmin(sqdists, axis=0)\\n\\n\\t\\t\\tnew_centroids = self.cluster_centroids(mydata, clusters, k)\\n\\t\\t\\tif np.array_equal(new_centroids, centroids):\\n\\t\\t\\t\\tbreak\\n\\n\\t\\t\\tcentroids = new_centroids\\n\\n\\t\\treturn clusters\",\n \"def make_all_zero(curr_clusters, k, num_of_cords):\\r\\n for i in range(k):\\r\\n for j in range(num_of_cords):\\r\\n curr_clusters[i][j] = 0\",\n \"def test_determine_k(self):\\n test_dir_name = os.path.dirname(__file__)\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"four_clusters.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\\"x\\\", \\\"y\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 4)\\n\\n feat_array_fn = os.path.join(\\n test_dir_name, \\\"data\\\", \\\"iris.csv\\\")\\n df = pd.read_csv(feat_array_fn)\\n feat_array = df[[\\n \\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\",\\n \\\"Petal.Width\\\"]].values\\n\\n clusterer = Clusterer(feat_array_fn, \\\"/dev/null\\\", [])\\n best_k = clusterer._determine_k(feat_array, 9)\\n\\n self.assertEqual(best_k, 2)\",\n \"def _cmeans0_kth(data, u_old, c, m, *para):\\n\\tk = para[0]\\n\\n\\t# Normalizing, then eliminating any potential zero values.\\n\\tu_old /= np.ones((c, 1)).dot(np.atleast_2d(u_old.sum(axis=0)))\\n\\tu_old = np.fmax(u_old, np.finfo(np.float64).eps)\\n\\n\\tum = u_old ** m\\n\\n\\t# remain the belonging rate >= the k-th max location of each cluster in um_c\\n\\tfilter_k = lambda row:row < sorted(row, reverse=True)[k-1]\\n\\tfail_indices = np.apply_along_axis(filter_k, axis=1, arr=u_old)\\n\\tum[fail_indices] = 0\\n\\n\\t# Calculate cluster centers\\n\\t# data1:2861,2; um:30,2861\\n\\tdata = data.T\\n\\tcntr = um.dot(data) / (np.ones((data.shape[1],1)).dot(np.atleast_2d(um.sum(axis=1))).T)\\n\\td = cdistance.get_center_distance(data, cntr)\\n\\t\\n\\td = np.fmax(d, np.finfo(np.float64).eps)\\n\\tjm = (um * d ** 2).sum()\\n\\n\\tu = d ** (- 2. / (m - 1))\\n\\tu /= np.ones((c, 1)).dot(np.atleast_2d(u.sum(axis=0)))\\n\\treturn cntr, u, jm, d\",\n \"def cluster(S, k=None, max_iter=100, visualize=False, points=None):\\n N = len(S)\\n if not k: \\n k = N\\n\\n S_bar = 1 - 2 * S\\n A = random_cluster_matrix((N, k))\\n\\n if visualize:\\n if not points: \\n raise ValueError(\\\"Cannot visualize clustering without points.\\\")\\n plt.ion()\\n\\n for _i in range(max_iter): \\n # Remove empty clusters\\n empty_columns = [i for i in range(k) if sum(A[:,i]) == 0]\\n A = remove_clusters(A, empty_columns)\\n k = len(A[0]) # Adjust number of clusters\\n\\n # Permute cluster membership that minimizes objective the most:\\n # (a) Compute M = ~SA\\n M = S_bar @ A\\n\\n # (b) Compute v\\n MoA = M * A\\n v = [min(M[i]) - sum(MoA[i]) for i in range(N)]\\n\\n # Check if we converged\\n if isclose(sum(v), 0, abs_tol=1e-5): \\n break\\n\\n # (c) Find the object X with the greatest optimization potential\\n X = np.argmin(v)\\n\\n # (d) Reassign X to the cluster C where C = argmin(M[X][j]) w.r.t. j\\n C = np.argmin(M[X])\\n A[X] = np.zeros((k))\\n A[X][C] = 1\\n\\n if _i % 10 == 0: \\n progress(_i, max_iter)\\n \\n if visualize: \\n plot(points, A, k) \\n\\n return A\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def k_means(data, k = 2, centroids = None, max_iters = 100) :\\r\\n if centroids == None :\\r\\n centroids = get_random_centroids(data, k)\\r\\n \\r\\n elif len(centroids) != k :\\r\\n AssertionError(\\\"Número de centroides no equivale a k\\\")\\r\\n \\r\\n for i in range(max_iters) :\\r\\n old_centroids = centroids\\r\\n \\r\\n assigned_centroids = assign_centroids(data, centroids)\\r\\n \\r\\n # Sum the data by cluster\\r\\n centroids = [[0]*data.shape[1]] * k\\r\\n values_in_centroid = [0] * k\\r\\n\\r\\n for i in range(k) :\\r\\n assigned_centroids_aux = np.column_stack([assigned_centroids]*data.shape[1])==i\\r\\n centroids[i] = np.sum(np.multiply(data, assigned_centroids_aux), axis = 0)\\r\\n values_in_centroid[i] = np.sum(assigned_centroids == i)\\r\\n\\r\\n # Mean\\r\\n for i in range(k) :\\r\\n if values_in_centroid[i] > 0 :\\r\\n centroids[i] = centroids[i]/values_in_centroid[i]\\r\\n\\r\\n centroids = np.stack(centroids, axis=0)\\r\\n\\r\\n error = sum([np.linalg.norm(centroids[i] - old_centroids[i]) for i in range(k)])\\r\\n if(error < 1e-5) : break\\r\\n \\r\\n \\r\\n return centroids\",\n \"def k_means(data, K):\\n\\n # randomly choose k centroids from the data points\\n centroids = data[np.random.choice(len(data), size=K, replace=False)]\\n\\n # assign each data point to closest centroid\\n distances = euclidean_distances(data, centroids)\\n labels = np.array([np.argmin(i) for i in distances])\\n\\n # track the largest centroid movements\\n deltas = []\\n\\n for i in range(MAX_ITERATIONS):\\n # keep track of the largest centroid movement for this iteration\\n max_delta_mu = 0\\n\\n for k in range(K):\\n # get all data points with label of this centroid k\\n cluster_points = data[labels == k]\\n if len(cluster_points) == 0:\\n continue\\n\\n # get mean r, g, and b values of all points in this cluster\\n # e.g. mu = [112.5, 95.6, 204.2]\\n mu = cluster_points.mean(axis=0)\\n\\n # get the max difference in an r,g, or b value\\n # abs(centroids[k] - mu) will return diff in RGB values\\n # e.g. abs(centroids[k] - mu) = [15.2, 25.4, 4.7]\\n max_delta_mu = max(max_delta_mu, abs(centroids[k] - mu).max())\\n\\n # update the kth centroid to the new mean value\\n centroids[k] = mu\\n\\n deltas.append(max_delta_mu)\\n\\n # assign each data point to closest centroid\\n distances = euclidean_distances(data, centroids)\\n labels = np.array([np.argmin(i) for i in distances])\\n\\n # stop the iterations early if the largest change in an r, g, or b value is < MIN_DELTA_MU\\n if max_delta_mu < MIN_DELTA_MU:\\n print(\\n f\\\"reached delta_mu {max_delta_mu:.2f} < {MIN_DELTA_MU} in {i} iterations for K={K}\\\")\\n break\\n\\n return centroids, labels, deltas\",\n \"def solve(list_k, examples, out_path, centers_=None,\\n conf_num=None, out_minus=True, out_iterations=False):\\n\\n # start_centers = utils.get_centers()\\n dimension = len(examples[0][0])\\n # print (dimension)\\n N = len(examples) # print(N)\\n for k in list_k:\\n # sys.stderr.write(str(k) + \\\"\\\\n\\\")\\n h = np.zeros((N, k), dtype=np.float64)\\n # responsibilities.fill(1/float(k))\\n pi_k = np.zeros(k, dtype=np.float64)\\n pi_k.fill(1/float(k))\\n # print\\n configuration = False\\n if centers_ == None:\\n centers = utils.get_centers(k, examples)\\n else:\\n centers = centers_\\n configuration = True\\n\\n matrix = np.identity(dimension, dtype=np.float64)\\n matrices = np.array([matrix] * k)\\n # print (matrices)\\n log = calc_log(examples, centers, matrices, pi_k)\\n # print (log)\\n\\n # output stuff\\n num_iter = 0\\n # if k == 4:\\n # groups = [list([])] * k\\n groups = []\\n for i in range(k):\\n groups.append([])\\n probabilities = dict()\\n\\n # if k == 4:\\n # print (h)\\n # print (pi_k)\\n # print (matrices)\\n # print (centers)\\n\\n if out_iterations:\\n iter_out = open(out_path + \\\"em-kmeans.dat\\\", \\\"w\\\")\\n iter_out.write(\\\"#iteracije: log-izglednost\\\\n\\\")\\n iter_out.write(\\\"--\\\\n\\\")\\n iter_out.write(\\\"#0: %.2lf\\\\n\\\" % log)\\n # buffer_all = \\\"K = %d\\\\n\\\" % k\\n # number of members in a certain group\\n\\n while True:\\n num_iter += 1\\n group_count = [0] * k\\n # init = dict()\\n group_dicts = []\\n for i in range(k):\\n group_dicts.append({})\\n # group_dicts = [] * k\\n # E step\\n # print (num_iter)\\n # changed = 0\\n for i in range(N):\\n x = examples[i][0]\\n mi_j = centers[0][0]\\n sigma_j = matrices[0]\\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\\n h[i][0] = p\\n sum_h = h[i][0]\\n probabilities[i] = p\\n group = examples[i][1]\\n if group not in group_dicts[0]:\\n group_dicts[0][group] = 1\\n else:\\n group_dicts[0][group] += 1\\n\\n # if p > \\n group_count[0] += 1\\n examples[i][2] = 0\\n\\n for j in range(1,k):\\n mi_j = centers[j][0]\\n sigma_j = matrices[j]\\n # print (sigma_j)\\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\\n if p2 > p:\\n group_count[examples[i][2]] -= 1\\n group_dicts[examples[i][2]][group] -= 1\\n if group not in group_dicts[j]:\\n group_dicts[j][group] = 1\\n else:\\n group_dicts[j][group] += 1\\n examples[i][2] = j\\n group_count[j] += 1\\n p = p2\\n probabilities[i] = p\\n\\n h[i][j] = p2\\n sum_h += h[i][j]\\n\\n h[i] /= sum_h\\n probabilities[i] /= sum_h\\n # print (\\\"$$$$$$$\\\")\\n # M step\\n # if num_iter == 1:\\n # print (h)\\n # sys.exit(1)\\n for i in range(k):\\n new_mi = np.zeros(dimension, dtype=np.float64)\\n sum_h = 0.\\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\\n\\n for j in range(N):\\n x = examples[j][0]\\n sum_h += h[j][i]\\n new_mi += h[j][i] * x\\n\\n new_mi /= sum_h\\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\\n # changed = 1\\n centers[i] = (new_mi, centers[i][1], centers[i][2])\\n\\n # mi = np.matrix(new_mi)\\n mi = new_mi\\n for j in range(N):\\n x = examples[j][0]\\n # print ((x-mi).T * (x - mi))\\n diff = np.matrix(x - mi)\\n # print (diff.T * diff)\\n new_sigma += h[j][i] * (diff.T * diff)\\n # break\\n\\n new_sigma /= sum_h\\n matrices[i] = new_sigma\\n new_pi = sum_h / float(N)\\n pi_k[i] = new_pi\\n\\n # print (matrices)\\n # if num_iter == 1:\\n # sys.exit(1)\\n\\n new_log = calc_log(examples, centers, matrices, pi_k)\\n\\n # print (new_log)\\n if abs(new_log - log) < EPS:\\n break\\n log = new_log\\n # if k == 4:\\n # print (log)\\n if out_iterations:\\n iter_out.write(\\\"#%d: %.2lf\\\\n\\\" % (num_iter, log))\\n # if changed == 0:\\n # break\\n\\n # set the groups for K = 4\\n # print (groups)\\n if not configuration and not out_iterations:\\n if k == 4:\\n for i in range(N):\\n # print (examples[i][2])\\n # print (groups)\\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\\n\\n with open(out_path + \\\"/em-k4.dat\\\", \\\"a\\\") as f:\\n for i in range(k):\\n # print (len(groups[i]))\\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\\n f.write(\\\"Grupa %d:\\\\n\\\" % (i+1))\\n for j in range(len(groups[i])):\\n f.write(groups[i][j][0] + \\\" %.2lf\\\\n\\\" % groups[i][j][1])\\n if i < k-1:\\n f.write(\\\"--\\\\n\\\")\\n\\n with open(out_path + \\\"/em-all.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"K = %d\\\\n\\\" % k)\\n for i in range(k):\\n f.write(\\\"c%d:\\\" % (i+1))\\n for j in range(dimension):\\n f.write(\\\" %.2lf\\\" % centers[i][0][j])\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"grupa %d: %d primjera\\\\n\\\" % ((i+1), group_count[i]))\\n f.write(\\\"#iter: %d\\\\n\\\" % num_iter)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n if k < 5:\\n f.write(\\\"--\\\\n\\\")\\n elif not out_iterations:\\n with open(out_path + \\\"/em-konf.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"Konfiguracija %d:\\\\n\\\" % conf_num)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n f.write(\\\"#iteracija: %d\\\\n\\\" % num_iter)\\n if out_minus == True:\\n f.write(\\\"--\\\\n\\\")\\n # if i < k - 1:\\n else:\\n iter_out.write(\\\"--\\\\n\\\")\\n for i in range(len(group_dicts)):\\n iter_out.write(\\\"Grupa %d:\\\" % (i+1))\\n buff = \\\"\\\"\\n for key in group_dicts[i]:\\n buff += \\\" \\\" + key + \\\" %d\\\" % group_dicts[i][key] + \\\",\\\"\\n\\n buff = buff[:-1]\\n iter_out.write(buff + \\\"\\\\n\\\")\\n # pass\",\n \"def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\\n # Get initial centers\\n n_samples, n_features = len(X), 2\\n init_ids = _get_init_centers(n_clusters, X)\\n if verbose:\\n print('Initial centers are: {}'.format(init_ids))\\n centers = init_ids\\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\\n cc, swapped = 0, True\\n while True:\\n swapped = False\\n for i in range(n_samples):\\n if i not in centers:\\n for j in range(len(centers)):\\n centers_ = deepcopy(centers)\\n centers_[j] = i\\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\\n if tot_cost_ < tot_cost:\\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\\n centers = centers_\\n swapped = True\\n if verbose:\\n print('Change centers to {}'.format(centers))\\n if cc > max_iter:\\n if verbose:\\n print('End Searching by reaching maximum iteration')\\n break\\n if not swapped:\\n if verbose:\\n print('End Searching by no swaps')\\n break\\n cc += 1\\n return centers, members, costs, tot_cost, dist_mat\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def run(\\n self,\\n number_of_clusters=None,\\n max_K=8,\\n method_clustering=\\\"pam\\\",\\n init_clustering=\\\"random\\\",\\n max_iter_clustering=100,\\n discart_value_JI=0.6,\\n bootstraps_JI=100,\\n bootstraps_p_value=100,\\n n_jobs=1,\\n verbose=1,\\n ):\\n\\n if number_of_clusters is None:\\n self.k = optimizer.optimizeK(\\n self.distance_matrix,\\n self.y.to_numpy(),\\n self.model_type,\\n max_K,\\n method_clustering,\\n init_clustering,\\n max_iter_clustering,\\n discart_value_JI,\\n bootstraps_JI,\\n self.random_state,\\n n_jobs,\\n verbose,\\n )\\n\\n if self.k == 1:\\n warnings.warn(\\\"No stable clusters were found!\\\")\\n return\\n\\n print(f\\\"Optimal number of cluster is: {self.k}\\\")\\n\\n else:\\n self.k = number_of_clusters\\n print(f\\\"Use {self.k} as number of cluster\\\")\\n\\n self.cluster_labels = (\\n kmedoids.KMedoids(\\n n_clusters=self.k,\\n method=method_clustering,\\n init=init_clustering,\\n metric=\\\"precomputed\\\",\\n max_iter=max_iter_clustering,\\n random_state=self.random_state,\\n )\\n .fit(self.distance_matrix)\\n .labels_\\n )\\n\\n (\\n self._data_clustering_ranked,\\n self.p_value_of_features,\\n ) = stats.calculate_global_feature_importance(\\n self.X, self.y, self.cluster_labels, self.model_type\\n )\\n self._p_value_of_features_per_cluster = (\\n stats.calculate_local_feature_importance(\\n self._data_clustering_ranked, bootstraps_p_value\\n )\\n )\",\n \"def k_means(data, k, max_iterations=100):\\n if len(data) < k:\\n raise ValueError('must have more data points than centers, got: {}'.format(len(data)))\\n\\n dim = 1 if len(np.shape(data)) == 1 else np.shape(data)[-1]\\n means = np.empty((k, dim))\\n\\n # initialize means to random points in dataset\\n taken = set()\\n for kidx in range(k):\\n rand_idx = np.random.randint(len(data))\\n while rand_idx in taken:\\n rand_idx = np.random.randint(len(data))\\n taken.add(rand_idx)\\n means[kidx, :] = data[rand_idx, :]\\n\\n prev_assignments = []\\n assignments = []\\n for idx in range(max_iterations):\\n\\n # check for convergence\\n if prev_assignments != [] and prev_assignments == assignments:\\n break\\n\\n # reset assignments\\n prev_assignments = assignments\\n assignments = []\\n\\n # assign to means\\n for sample in data:\\n min_k_idx = 0\\n min_k_dist = utils.euclidean_dist(means[0], sample)\\n for kidx in range(1, k):\\n k_dist = utils.euclidean_dist(means[kidx], sample)\\n if k_dist < min_k_dist:\\n min_k_dist = k_dist\\n min_k_idx = kidx\\n assignments.append(min_k_idx)\\n\\n # show intermediate cluster assignments\\n # utils.plot_1d_data_assigments(data, means, assignments)\\n\\n # recompute means\\n means = np.zeros((k, dim))\\n mean_counts = collections.defaultdict(int)\\n for sample, kidx in zip(data, assignments):\\n means[kidx, :] += sample\\n mean_counts[kidx] += 1\\n \\n for kidx, count in mean_counts.iteritems():\\n means[kidx] /= float(count)\\n \\n return means, assignments\",\n \"def KMeans(dataTable, k, epsilon=0.00001, srcDims = 1000000000000000, iters=20, normData = False):\\n #load up the configuration\\n kmOptions = KMeansConfig(dataTable,k,epsilon,srcDims)\\n \\n \\n #load and format the table for use.\\n data = loadMatrix(dataTable)[:,:kmOptions['sourceDims']]\\n \\n #check if we should normalise the data (this is really quick and dirty, replace it with something better)\\n if normData:\\n dmax = amax(data)\\n dmin = amin(data)\\n data = (data-dmin)/(dmax-dmin+0.00000001)\\n \\n \\n #make our starting point solutions from the dataset\\n solutions = [array(random.sample(data,k)) for i in xrange(iters)]\\n \\n #chunk solutions if necessary\\n for i in xrange(len(solutions)):\\n sol = []\\n while len(solutions[i]) > kmOptions['chunkSize']:\\n sol.append(solutions[i][:kmOptions['chunkSize']])\\n solutions[i] = solutions[i][kmOptions['chunkSize']:]\\n sol.append(solutions[i])\\n solutions[i] = sol\\n \\n #create our chunked problem data\\n dataChunks = []\\n while len(data) > kmOptions['chunkSize']:\\n dataChunks.append(data[:kmOptions['chunkSize']])\\n data = data[kmOptions['chunkSize']:]\\n dataChunks.append(data)\\n kNorm = (len(dataChunks)-1)+len(dataChunks[-1])/float(len(dataChunks[0]))\\n \\n #create the CUDA kernels\\n program = SourceModule(open(KernelLocation+\\\"KMEANS_LABEL.nvcc\\\").read())\\n prg = program.get_function(\\\"KMEANS_LABEL\\\")\\n program = SourceModule(open(KernelLocation+\\\"KMEANS_UPDATE.nvcc\\\").read())\\n prg2 = program.get_function(\\\"KMEANS_UPDATE\\\")\\n t0 = time.time()\\n \\n #store the resultant performance of each solution here\\n results = []\\n finalSols = []\\n \\n #make GPU allocations and support variables\\n total = 0.\\n dists = [numpy.zeros(kmOptions['chunkSize']).astype(numpy.float32)+10000000000000000. for i in xrange(len(dataChunks))] #this is used as an intermediate step\\n labels = [numpy.zeros(kmOptions['chunkSize']).astype(numpy.uint32) for i in xrange(len(dataChunks))] #this is used as an intermediate step\\n data_gpu = drv.mem_alloc(dataChunks[0].nbytes)\\n k_gpu = drv.mem_alloc(solutions[0][0].nbytes)\\n labels_gpu = drv.mem_alloc(labels[0].nbytes)\\n dists_gpu = drv.mem_alloc(dists[0].nbytes)\\n \\n #calculate KMeans\\n for sol in solutions:\\n t0 = time.time()\\n for i in xrange(10000):\\n #Step 1: find all the closest labels\\n for i in xrange(len(sol)):\\n #copy in blank distances, labels, and the label coordinates\\n drv.memcpy_htod(k_gpu, sol[i])\\n for j in xrange(len(dataChunks)):\\n drv.memcpy_htod(data_gpu, dataChunks[j])\\n drv.memcpy_htod(labels_gpu, labels[j])\\n drv.memcpy_htod(dists_gpu, dists[j])\\n prg(k_gpu,\\n data_gpu,\\n kmOptions[\\\"dimensions\\\"],\\n labels_gpu,\\n dists_gpu,\\n kmOptions['k'],\\n kmOptions['dataSize'],\\n kmOptions['chunkSize'],\\n numpy.int64(i*kmOptions['chunkSize']), #k offset\\n numpy.int64(j*kmOptions['chunkSize']), #data offset\\n kmOptions['maxThreads'],\\n block=kmOptions['block'],\\n grid=kmOptions['grid'])\\n drv.memcpy_dtoh(labels[i], labels_gpu)\\n #Step 2: find the new averages\\n old_sol = [s.copy() for s in sol]\\n for i in xrange(len(sol)):\\n #load up a blank set of k matrices\\n drv.memcpy_htod(k_gpu, sol[i]*0.)\\n for j in xrange(len(dataChunks)):\\n drv.memcpy_htod(data_gpu, dataChunks[j])\\n drv.memcpy_htod(labels_gpu, labels[j])\\n prg2(k_gpu,\\n data_gpu,\\n kmOptions[\\\"dimensions\\\"],\\n labels_gpu,\\n kmOptions['k'],\\n kmOptions['dataSize'],\\n kmOptions['chunkSize'],\\n numpy.int64(i*kmOptions['chunkSize']), #label offset\\n numpy.int64(j*kmOptions['chunkSize']), #data offset\\n kmOptions['maxThreads'],\\n block=kmOptions['block'],\\n grid=kmOptions['grid'])\\n drv.memcpy_dtoh(sol[i], k_gpu)\\n sol[i] /= kNorm #final normalisation\\n #Step 3: check that the update distance is larger than epsilon\\n total = 0.\\n for j in xrange(len(sol)):\\n tmp = sol[j]-old_sol[j]\\n tmp = tmp*tmp\\n total += sum([sum(t**0.5) for t in tmp])\\n if total/kmOptions['dataSize'] < kmOptions['eps']:\\n break\\n print \\\"solution done in \\\",time.time()-t0\\n results.append((total,len(results)))\\n finalSols.append(numpy.concatenate(sol)[:kmOptions['dataSize']])\\n results.sort()\\n return finalSols[results[0][1]]\",\n \"def kmeans_clustering(proj_df, k):\\r\\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\\r\\n k_means.fit(proj_df)\\r\\n labels= k_means.predict(proj_df)\\r\\n \\r\\n return labels\",\n \"def naive_sharding(self, ds, k):\\n\\n n = np.shape(ds)[1]\\n m = np.shape(ds)[0]\\n centroids = np.mat(np.zeros((k,n)))\\n\\n # Sum all elements of each row, add as col to original dataset, sort\\n composite = np.mat(np.sum(ds, axis=1))\\n ds = np.append(composite.T, ds, axis=1)\\n ds.sort(axis=0)\\n\\n # Step value for dataset sharding\\n step = floor(m/k)\\n\\n # Vectorize mean ufunc for numpy array\\n vfunc = np.vectorize(self._get_mean)\\n\\n # Divide matrix rows equally by k-1 (so that there are k matrix shards)\\n # Sum columns of shards, get means; these column means are centroids\\n for j in range(k):\\n if j == k-1:\\n centroids[j:] = vfunc(np.sum(ds[j*step:,1:], axis=0), step)\\n else:\\n centroids[j:] = vfunc(np.sum(ds[j*step:(j+1)*step,1:], axis=0), step)\\n\\n return centroids\",\n \"def assignment(self, addresses, centroids, k):\\n newClusters = {}\\n print centroids\\n for (lat, long) in addresses:\\n minDistance = float('Inf')\\n minIndex = 0\\n for i in range(k):\\n if pow(self.euclideanDistance((lat, long), centroids[i]),2) < minDistance:\\n minDistance = pow(self.euclideanDistance((lat, long), centroids[i]),2)\\n minIndex = i\\n if minIndex in newClusters:\\n newClusters[minIndex].append((lat, long))\\n else:\\n newClusters[minIndex] = [(lat, long)]\\n return newClusters\",\n \"def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\\r\\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\\r\\n\\r\\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\\r\\n #loop through first element separately so that subsequent values can be appended\\r\\n node_cluster_set_test_str, ds_arr = [], []\\r\\n for prec in prec_vals:\\r\\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\\r\\n for clus in node_cluster_set_test_str_app:\\r\\n #add cluster to cluster set\\r\\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\\r\\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\\r\\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\\r\\n clus_num_arr.append(node_num)\\r\\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\\r\\n prec_arr.append(prec)\\r\\n recall_arr.append(recall)\\r\\n F1_arr.append(F1)\\r\\n\\r\\n return clus_num_arr, prec_arr, recall_arr, F1_arr\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def get_clusters(self,points):\\n self.points = points\\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\\n ##self.hull = \\n return self.__dabest\",\n \"def kmeans(X, k, iterations=1000):\\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\\n return None, None\\n if not isinstance(k, int) or k <= 0:\\n return None, None\\n if not isinstance(iterations, int) or iterations <= 0:\\n return None, None\\n n, d = X.shape\\n X_min = X.min(axis=0)\\n X_max = X.max(axis=0)\\n C = np.random.uniform(X_min, X_max, size=(k, d))\\n\\n for i in range(iterations):\\n centroids = np.copy(C)\\n centroids_extended = C[:, np.newaxis]\\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\\n clss = np.argmin(distances, axis=0)\\n for c in range(k):\\n if X[clss == c].size == 0:\\n C[c] = np.random.uniform(X_min, X_max, size=(1, d))\\n else:\\n C[c] = X[clss == c].mean(axis=0)\\n\\n centroids_extended = C[:, np.newaxis]\\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\\n clss = np.argmin(distances, axis=0)\\n\\n if (centroids == C).all():\\n break\\n\\n return C, clss\",\n \"def lloyds_algorithm(X, k, T):\\n n, d = X.shape\\n\\n # Initialize clusters random.\\n clustering = np.random.randint(0, k, (n,))\\n centroids = np.zeros((k, d))\\n\\n # Used to stop if cost isn't improving (decreasing)\\n cost = 0\\n oldcost = 0\\n\\n # Column names\\n # print(\\\"Iterations\\\\tCost\\\")\\n for i in range(T):\\n\\n # Update centroid\\n centroids = np.zeros((k, d))\\n # YOUR CODE HERE\\n numberOfPointsInClusters = np.zeros((k,))\\n for idx, point in enumerate(clustering):\\n numberOfPointsInClusters[point] += 1\\n centroids[point] += X[idx]\\n for n in range(k):\\n if numberOfPointsInClusters[n] == 0:\\n numberOfPointsInClusters[n] = float('-inf')\\n centroids = [centroid / numberOfPointsInClusters[idx] for idx, centroid in enumerate(centroids)]\\n # END CODE\\n\\n # Update clustering\\n\\n # YOUR CODE HERE\\n for idx, point in enumerate(X):\\n clustering[idx] = np.argmin([np.linalg.norm(point - cluster) for cluster in centroids])\\n # END CODE\\n\\n # Compute and print cost\\n cost = 0\\n for j in range(n):\\n cost += np.linalg.norm(X[j] - centroids[clustering[j]]) ** 2\\n # print(i + 1, \\\"\\\\t\\\\t\\\", cost)\\n\\n # Stop if cost didn't improve more than epislon (decrease)\\n if np.isclose(cost, oldcost): break # TODO\\n oldcost = cost\\n\\n return clustering, centroids, cost\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\\n res = []\\n for n_clusters in n_clusters_considered:\\n res.append([])\\n for _ in range(n_repeats):\\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\\n print(X.val.shape)\\n print(X_restricted.val.shape)\\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\\n res[-1].append(evaluator_X.weighted_average) \\n return res\",\n \"def run(self, points, K):\\n # Get size\\n D, N = points.shape\\n\\n # DxK array initialiezd with random points\\n centroids = points[:, np.random.permutation(N)[:K]]\\n\\n # Assigments 1xN array\\n labels = np.zeros(N)\\n\\n for it in np.arange(self.niter):\\n # 1. Compute distance to all cluster\\n #v1 dirty\\n distances = np.zeros([K, N])\\n for n in np.arange(N):\\n for k in np.arange(K):\\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \\n\\n # 2. Update assigments\\n # v1 dirty\\n for n in np.arange(N):\\n kmin = 0\\n for k in np.arange(1, K):\\n if distances[k, n] <= distances[kmin, n]:\\n kmin = k\\n labels[n] = kmin\\n # v2 quicker\\n #labels = np.argmin(distances, axis=1)\\n\\n # 3. Update mean\\n for k in np.arange(K):\\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\\n\\n return centroids, labels\",\n \"def test_example(self): \\n num_clusters = 2\\n iterations = 5\\n ts1 = 2.5 * np.random.randn(100,) + 3\\n X_1 = pd.Series(ts1)\\n ts2 = 2 * np.random.randn(100,) + 5\\n X_2 = pd.Series(ts2)\\n ts3 = -2.5 * np.random.randn(100,) + 3\\n X_3 = pd.Series(ts3)\\n list_of_series = [X_1, X_2, X_3]\\n from pynuTS.clustering import DTWKmeans\\n clts = DTWKmeans(num_clust = num_clusters, num_iter = iterations)\\n clts.fit(list_of_series)\\n ts4 = 3.5 * np.random.randn(100,) + 2\\n ts5 = -3.5 * np.random.randn(100,) + 2\\n X_4 = pd.Series(ts4)\\n X_5 = pd.Series(ts5)\\n list_new = [X_4, X_5]\\n clustering_dict = clts.predict(list_new)\\n\\n assert type(clustering_dict) is dict\\n assert len(clustering_dict) == num_clusters\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def _cluster(self):\\n self._not_included = self.data\\n self.leaves = []\\n flag = int(rand() * len(self.data))\\n flag = self._generate(flag)\\n while len(self._not_included) > 0:\\n flag = self._generate(flag)\\n if flag == -1:\\n break\\n pass\\n self._remember.append({\\n 'threshold': self._base_threshold,\\n 'result': len(self.leaves)\\n })\\n print(len(self._remember), {\\n 'threshold': self._base_threshold,\\n 'result': len(self.leaves)\\n })\\n return\",\n \"def splitCluster(self, cluster):\\n\\t\\tmaxValue = self.getMaxValue(self.clusterList[cluster])\\n\\t\\tminValue = self.getMinValue(self.clusterList[cluster])\\n\\t\\tmidValue = round(maxValue - ((maxValue - minValue) / 2))\\n\\n\\t\\t# Create a set of centroid\\n\\t\\tfirstCentroid = random.randint(minValue, midValue)\\n\\t\\tsecondCentroid = random.randint(midValue, maxValue)\\n\\n\\t\\tcpyCluster = self.clusterList[cluster]\\n\\t\\tnextName = str(len(self.clusterList))\\n\\t\\tself.clusterList[cluster] = []\\n\\t\\tself.clusterList[nextName] = []\\n\\n\\t\\tfor value in cpyCluster:\\n\\t\\t\\tif abs(value - firstCentroid) < abs(value - secondCentroid):\\n\\t\\t\\t\\tself.clusterList[cluster].append(value)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.clusterList[nextName].append(value)\\n\\t\\t\\tpass\\n\\t\\tpass\\n\\t\\tprint(self.clusterList)\",\n \"def generate_clusters(self, medoids, samples):\\n clusters = []\\n for i in range(0, medoids.shape[0]):\\n clusters.append([])\\n for currentSampleIndex in range(0, samples.shape[0]):\\n currentSample = samples[currentSampleIndex]\\n minDistance = np.inf\\n minDistanceIndex = 0\\n for currentMedoidIndex in range(0, medoids.shape[0]):\\n currentDistance = distance.euclidean(currentSample, medoids[currentMedoidIndex])\\n if (currentDistance < minDistance):\\n minDistance = currentDistance\\n minDistanceIndex = currentMedoidIndex\\n clusters[minDistanceIndex].append(currentSample)\\n return clusters\\n pass\",\n \"def calc_final_clusters(sp_initial, km_initial):\\r\\n sp_final = kc.kmeans(T.tolist(), sp_initial, k, n, k, MAX_ITER)\\r\\n km_final = kc.kmeans(data.tolist(), km_initial, k, n, d, MAX_ITER)\\r\\n if km_final is None or sp_final is None:\\r\\n exit(1)\\r\\n spectral_clusters = np.array(sp_final)\\r\\n kmeans_clusters = np.array(km_final)\\r\\n\\r\\n return spectral_clusters, kmeans_clusters\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7273148","0.7161901","0.71461064","0.70277727","0.6989481","0.6961698","0.69509083","0.6936706","0.69362247","0.68879706","0.68621993","0.67435825","0.6723467","0.67071426","0.67059225","0.66942155","0.66667116","0.6627539","0.6592454","0.6569137","0.6537801","0.6528765","0.6499644","0.6492428","0.647455","0.6472392","0.6444663","0.6442534","0.6439751","0.64324623","0.64267725","0.64208215","0.64065576","0.63955456","0.639385","0.6372308","0.6363723","0.63482726","0.634722","0.63421595","0.6317635","0.63130045","0.63085884","0.63050145","0.62973076","0.6293844","0.6288437","0.62801075","0.62680364","0.6244583","0.6244415","0.6213857","0.6208636","0.62023115","0.61944485","0.6186453","0.6177738","0.6173396","0.6170498","0.6163259","0.6149199","0.6146563","0.6118387","0.6115522","0.6113895","0.61097664","0.60995275","0.60968226","0.608345","0.60830784","0.60771286","0.6072543","0.60641956","0.6062196","0.6056038","0.60467494","0.60448337","0.6021256","0.60098916","0.59934187","0.5992892","0.598991","0.5989241","0.59858817","0.5985852","0.5985706","0.5984454","0.5984454","0.5977868","0.5977432","0.59729606","0.5972182","0.59690666","0.5967947","0.59678805","0.5966121","0.5963274","0.5955622","0.5952528","0.59503245"],"string":"[\n \"0.7273148\",\n \"0.7161901\",\n \"0.71461064\",\n \"0.70277727\",\n \"0.6989481\",\n \"0.6961698\",\n \"0.69509083\",\n \"0.6936706\",\n \"0.69362247\",\n \"0.68879706\",\n \"0.68621993\",\n \"0.67435825\",\n \"0.6723467\",\n \"0.67071426\",\n \"0.67059225\",\n \"0.66942155\",\n \"0.66667116\",\n \"0.6627539\",\n \"0.6592454\",\n \"0.6569137\",\n \"0.6537801\",\n \"0.6528765\",\n \"0.6499644\",\n \"0.6492428\",\n \"0.647455\",\n \"0.6472392\",\n \"0.6444663\",\n \"0.6442534\",\n \"0.6439751\",\n \"0.64324623\",\n \"0.64267725\",\n \"0.64208215\",\n \"0.64065576\",\n \"0.63955456\",\n \"0.639385\",\n \"0.6372308\",\n \"0.6363723\",\n \"0.63482726\",\n \"0.634722\",\n \"0.63421595\",\n \"0.6317635\",\n \"0.63130045\",\n \"0.63085884\",\n \"0.63050145\",\n \"0.62973076\",\n \"0.6293844\",\n \"0.6288437\",\n \"0.62801075\",\n \"0.62680364\",\n \"0.6244583\",\n \"0.6244415\",\n \"0.6213857\",\n \"0.6208636\",\n \"0.62023115\",\n \"0.61944485\",\n \"0.6186453\",\n \"0.6177738\",\n \"0.6173396\",\n \"0.6170498\",\n \"0.6163259\",\n \"0.6149199\",\n \"0.6146563\",\n \"0.6118387\",\n \"0.6115522\",\n \"0.6113895\",\n \"0.61097664\",\n \"0.60995275\",\n \"0.60968226\",\n \"0.608345\",\n \"0.60830784\",\n \"0.60771286\",\n \"0.6072543\",\n \"0.60641956\",\n \"0.6062196\",\n \"0.6056038\",\n \"0.60467494\",\n \"0.60448337\",\n \"0.6021256\",\n \"0.60098916\",\n \"0.59934187\",\n \"0.5992892\",\n \"0.598991\",\n \"0.5989241\",\n \"0.59858817\",\n \"0.5985852\",\n \"0.5985706\",\n \"0.5984454\",\n \"0.5984454\",\n \"0.5977868\",\n \"0.5977432\",\n \"0.59729606\",\n \"0.5972182\",\n \"0.59690666\",\n \"0.5967947\",\n \"0.59678805\",\n \"0.5966121\",\n \"0.5963274\",\n \"0.5955622\",\n \"0.5952528\",\n \"0.59503245\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73497814"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9482,"cells":{"query":{"kind":"string","value":"Create a delta separated data set. Generate a set of centers for the clusters and from each center draw size number of points that constitute the points in that cluster. Then return a dataset of all points."},"document":{"kind":"string","value":"def create_dataset(dims, size, num_clusters=20):\n clusters, delta = gen_k_centers(num_clusters, dims)\n return _create_constrained_dataset(clusters, delta, size)"},"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 _create_constrained_dataset(centers, delta, size):\n dataset = []\n count = 0\n for i, c in enumerate(centers):\n for j in range(size):\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\n direction = x / np.linalg.norm(x)\n magnitude = np.random.uniform(0.0, 0.5 * delta)\n # magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED\n dataset.append((c + magnitude * direction, i, count))\n count += 1\n return dataset","def get_clusters(self,points):\n self.points = points\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\n ##self.hull = \n return self.__dabest","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\n\n # generate clusters of blobs\n generated_points_x, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_x,\n cluster_std=std,\n n_features=1,\n )\n\n generated_points_y, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_y,\n cluster_std=std,\n n_features=1,\n )\n\n # remove decimals\n generated_points_x = generated_points_x.astype(\"int\")\n generated_points_y = generated_points_y.astype(\"int\")\n\n ind_delete = np.logical_or.reduce(\n (\n generated_points_x < 0,\n generated_points_y < 0,\n generated_points_x > xsize - 1,\n generated_points_y > ysize - 1,\n ),\n )\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n\n return generated_points_x, generated_points_y","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def calculate_all_distances_to_center(self):\n all_distances = pd.DataFrame()\n for label in np.unique(self.embedding_df['cluster']): \n distance_df = self.calculate_distances_for_cluster(label)\n all_distances = pd.concat([all_distances, distance_df])\n \n self.embedding_df = self.embedding_df.merge(all_distances, left_index=True, right_index=True)","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def prepare_data_for_d(self):\n\n center_nodes = []\n neighbor_nodes = []\n labels = []\n for i in self.root_nodes:\n if np.random.rand() < config.update_ratio:\n # self.graph[i] = [neighbors of i]\n pos = self.graph[i]\n neg, _ = self.sample(i, self.trees[i], len(pos), for_d=True)\n # print(\"tree_i_d: \", self.trees[i])\n # print(\"neg_samples: \", neg)\n # print(\"neg is: \", neg)\n if len(pos) != 0 and neg is not None:\n # positive samples\n center_nodes.extend([i] * len(pos))\n neighbor_nodes.extend(pos)\n labels.extend([1] * len(pos))\n\n # negative samples\n center_nodes.extend([i] * len(pos))\n neighbor_nodes.extend(neg)\n labels.extend([0] * len(neg))\n # print(\"cen: \", center_nodes)\n return center_nodes, neighbor_nodes, labels","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def generate_clusters(df):\n\n df_size = df.shape[0]\n print(df_size)\n n_clusters = 0\n percent_min_pts = 0.105\n min_clusters = 3\n while (n_clusters != min_clusters):\n print(\"percent_min_pts\", percent_min_pts)\n min_cluster_pts = math.floor(df_size * percent_min_pts)\n print(\"min_cluster_pts\", min_cluster_pts)\n\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\n print(df.head())\n clusterer.fit(df)\n cluster_groups = {}\n labels = clusterer.labels_\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n n_clusters = len(set(labels))\n print(\"n_clusters\", n_clusters)\n multiplier = abs(n_clusters - min_clusters) * 0.001\n print(\"multiplier\", multiplier)\n if n_clusters > min_clusters:\n percent_min_pts += multiplier\n else:\n percent_min_pts -= multiplier\n print(\"percent_min_pts\", percent_min_pts)\n return labels","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def assign_points(data, centers):\n result = {c: [] for c in centers}\n for point in data:\n min_distance = float(\"inf\")\n for c in centers:\n dist = euclidean_distance(point, c)\n if dist < min_distance:\n min_distance = dist\n min_center = c\n result[min_center].append(point)\n\n return result","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\n self.d = d\n\n # 95% of data lies in a 2*sigma ball around the mean.\n # For unit variance normal, the 2*sigma ball mean the centers\n # should be at distance of 4 in the d dimensional space.\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\n cov = np.eye(d)\n\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\n # print(dist_mean)\n # cov = np.eye(d)\n\n frac = int(1 / pos_fraction)\n\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\n\n self.X = np.vstack((cluster1, cluster2))\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\n\n # Make blobs\n # if True:\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def create_dataset(n_clusters, n_dim, n_samples, mean=None, std=None, seed=None):\n if seed is not None:\n np.random.seed(seed)\n\n if mean is None:\n means = [np.random.randint(-(i + 1), (i + 1),\n n_dim).astype(np.float32) for i in range(n_clusters)]\n if std is None:\n stds = []\n for _ in range(n_clusters):\n a = np.diag(random.rand(n_dim))\n stds.append(a)\n\n data_set = []\n cluster_id = []\n for i, mean, std in zip(range(n_clusters), means, stds):\n data_set.append(np.random.multivariate_normal(mean, std, n_samples))\n cluster_id.append(np.ones(n_samples) * i)\n\n data_set = np.concatenate(data_set)\n cluster_id = np.concatenate(cluster_id)\n sample_idx = np.random.choice(data_set.shape[0], n_samples, replace=False)\n\n # Return correct amount of samples\n return data_set[sample_idx, :], cluster_id[sample_idx]","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def kMeans(d, k):\n #First get the random centroids from the data\n newCentroids = getRandomCentroids(d, k)\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\n\n #Get the clusters from these random centroids\n clusters = initiateCentroid(d, newCentroids, k)\n oldCentroids = []\n\n counter = 0\n #While the old centroids are not equal to the new ones\n while oldCentroids != newCentroids:\n #old is equal to new\n oldCentroids = newCentroids\n #Calculate the new centroids\n k, newCentroids = calcCentroids(d, clusters)\n #Calculate the new clusters\n clusters = initiateCentroid(d, newCentroids, k)\n #Count how many iterations\n counter += 1\n\n return counter, clusters","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def assign_points(data_points, centers):\n assignments = []\n for point in data_points:\n shortest = 10000 # positive infinity\n shortest_index = 0\n for i in range(len(centers)):\n val = distance(point, centers[i])\n if val < shortest:\n shortest = val\n shortest_index = i\n assignments.append(shortest_index)\n return assignments","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def generate_clusters_n(df, tweet_deleted):\n # cluster_labels, n_clusters = dbscan(normalised_df, true_labels, 0.25, 30)\n # print(\"normalised_df.head()\", normalised_df.head())\n clusterer = hdbscan.HDBSCAN(min_cluster_size=10)\n clusterer.fit(df)\n labels = clusterer.labels_\n cluster_groups = {}\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n df[\"cluster\"] = labels\n df[\"tweet_deleted\"] = tweet_deleted\n cluster_results = list()\n for cluster_no in cluster_groups.keys():\n print(\"++++++++++\")\n print(\"cluster_no\", cluster_no)\n cluster_result = list()\n cluster_result.append(cluster_no)\n\n cluster = df.mask('cluster', cluster_no)\n print(cluster_no, \" :\")\n tweet_deleted = cluster.mask('tweet_deleted', True).shape[0]\n not_tweet_deleted = cluster.mask('tweet_deleted', False).shape[0]\n print(\"deleted_df len:\", tweet_deleted)\n print(\"not_deleted_df len:\", not_tweet_deleted)","def initiateCentroid(data_points, centroids, k):\n #Create empty list in list (amount is k)\n AvgCentroids = [[] for i in range(k)]\n\n #For each datapoint in all datapoints\n for dp in data_points:\n dis = []\n #For each centroid in centroids\n for c in range(len(centroids)):\n #Calculate the euclidean distance between those points and append\n #to distance list\n dis.append(calcEuclideanDistance(dp, centroids[c]))\n \n #Get the smallest value of the list and the index\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\n\n #The index of the smallest value is the index where it will be added\n #to the avgCentroids list. So it represents the number of the cluster\n AvgCentroids[idx].append(dp)\n \n return AvgCentroids","def generate_k(data_set, k):\n centers = []\n dimensions = len(data_set[0])\n min_max = defaultdict(int)\n\n for point in data_set:\n for i in range(dimensions):\n val = point[i]\n min_key = 'min_{0}d'.format(i)\n max_key = 'max_{0}d'.format(i)\n if min_key not in min_max or val < min_max[min_key]:\n min_max[min_key] = val\n if max_key not in min_max or val > min_max[max_key]:\n min_max[max_key] = val\n\n for _k in range(k):\n rand_point = []\n for i in range(dimensions):\n min_val = min_max['min_{0}d'.format(i)]\n max_val = min_max['max_{0}d'.format(i)]\n \n rand_point.append(uniform(min_val, max_val))\n centers.append(rand_point)\n return centers","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def get_disc_data_sets(sample_size):\n log.info(\"MAKING DATA SETS\")\n\n fakes = generate_fakes(int(sample_size / 2))\n reals = get_reals(int(sample_size / 2))\n total = numpy.concatenate((reals, fakes))\n real_labels = numpy.ones([len(reals)])\n fake_labels = numpy.zeros([len(fakes)])\n total_labels = numpy.concatenate((real_labels, fake_labels))\n return get_discriminator_splits(total, total_labels)","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def run(self, points, K):\n # Get size\n D, N = points.shape\n\n # DxK array initialiezd with random points\n centroids = points[:, np.random.permutation(N)[:K]]\n\n # Assigments 1xN array\n labels = np.zeros(N)\n\n for it in np.arange(self.niter):\n # 1. Compute distance to all cluster\n #v1 dirty\n distances = np.zeros([K, N])\n for n in np.arange(N):\n for k in np.arange(K):\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \n\n # 2. Update assigments\n # v1 dirty\n for n in np.arange(N):\n kmin = 0\n for k in np.arange(1, K):\n if distances[k, n] <= distances[kmin, n]:\n kmin = k\n labels[n] = kmin\n # v2 quicker\n #labels = np.argmin(distances, axis=1)\n\n # 3. Update mean\n for k in np.arange(K):\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\n\n return centroids, labels","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def dbscan(dataList, maxClusterNum, eps, minPts):\n unvisitedPt = list(dataList)\n clusterSizeList = []\n clusterSeedList = []\n lastClusterID = 0\n # lookup all unvisited Points\n while (len(unvisitedPt) != 0):\n idx = randint(0, len(unvisitedPt) - 1)\n cur = unvisitedPt[idx]\n cur.isVisited = True\n del unvisitedPt[idx]\n\n # Create new cluster if 'cur' pt. is core object\n neighborhood = findNeighbor(cur, dataList, eps)\n if (len(neighborhood) >= minPts):\n cur.label = lastClusterID\n clusterSeedList.append(cur)\n clusterSize = 1\n idx = -1\n # find all density-connected points(neighborhood)\n while (idx < len(neighborhood) - 1):\n idx += 1\n if (neighborhood[idx].isVisited):\n continue\n neighborhood[idx].isVisited = True\n unvisitedPt.remove(neighborhood[idx])\n nextNeighbor = findNeighbor(neighborhood[idx], dataList, eps)\n if (len(nextNeighbor) >= minPts):\n # extend neighborhood without duplicate\n neighborhood = neighborhood \\\n + [x for x in nextNeighbor if x not in neighborhood and not x.isVisited]\n if (neighborhood[idx].label == -1):\n neighborhood[idx].label = lastClusterID\n clusterSize += 1\n clusterSizeList.append((lastClusterID, clusterSize))\n lastClusterID += 1\n\n # Create labelConverter to remove extra clusters if exist.\n labelConverter = dict()\n labelConverter[-1] = -1\n if (lastClusterID <= maxClusterNum): # no need to remove extra clusters\n for i in range(maxClusterNum):\n labelConverter[i] = i\n else: # create labelConverter that remove extra clusters\n clusterSizeList.sort(key=itemgetter(1), reverse=True)\n for i in range(maxClusterNum):\n labelConverter[clusterSizeList[i][0]] = i\n for i in range(maxClusterNum, lastClusterID):\n labelConverter[clusterSizeList[i][0]] = -1\n # recluster(dataList, labelConverter, clusterSeedList, eps, minPts)\n return labelConverter","def distortion_of_kmeans_clustering(data_table):\n num_iritations = 5\n singleton_list = []\n for line in data_table:\n singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\n distortion_list = []\n for num in range(20, 5, -1):\n cluster_list = kmeans_clustering(singleton_list,num, num_iritations)\n distortion = compute_distortion(data_table, cluster_list)\n distortion_list.append(distortion)\n return distortion_list\n\n#####################################################################\n# Code to load cancer data, compute a clustering and\n# visualize the results\n\n\n# def run_example():\n# \"\"\"\n# Load a data table, compute a list of clusters and\n# plot a list of clusters\n#\n# Set DESKTOP = True/False to use either matplotlib or simplegui\n# \"\"\"\n# data_table = load_data_table(DATA_3108_URL)\n# singleton_list = []\n# for line in data_table:\n# singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\n num_clusters = 16\n # cluster_list = sequential_clustering(singleton_list, num_clusters)\n # print(\"Displaying\", len(cluster_list), \"sequential clusters\")\n #\n # cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, num_clusters)\n # print(\"Displaying\", len(cluster_list), \"hierarchical clusters\")\n #\n # cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, num_clusters, 5)\n # print(\"Displaying\", len(cluster_list), \"k-means clusters\")\n\n # draw the clusters using matplotlib or simplegui\n #\n # if DESKTOP:\n # # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, False)\n # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, True) #add cluster centers\n\n # else:\n # alg_clusters_simplegui.PlotClusters(data_table, cluster_list) # use toggle in GUI to add cluster centers","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def gen_clusters(links, posts):\n\n clusters = list(iter_clusters(links, posts))\n return clusters","def plotPoints(vec, centers = None, numcolors = 2):\n\n try:\n import matplotlib.pyplot\n from mpl_toolkits.mplot3d import Axes3D\n except:\n raise ImportError, \"matplotlib package not found.\"\n\n markers = ['o', '^', 'x']\n labels = [\"Cluster 1\", \"Cluster 2\", \"Morning Data\", \"Evening Data\"]\n handles = []\n count = 0\n \n fig = matplotlib.pyplot.figure()\n ax1 = fig.add_subplot(111)\n\n for i in range(len(vec)):\n for v in vec[i]:\n col = getColor(i, numcolors, decimal = True)\n col = (0, max(col[1] - 0.2, 0), col[2] - 0.1)\n ax1.scatter(v[1], v[2], color = col, s = 100, marker = markers[v[0]])\n\n matplotlib.pyplot.show()","def start_algorithm(self):\r\n self.kmeans.set_data(self.tweets)\r\n clusters = self.kmeans.start_algorithm()\r\n min_size = len(self.tweets) * 0.005\r\n if min_size < 50:\r\n min_size = 50\r\n max_size = len(self.tweets) * 0.20\r\n\r\n amount = 0\r\n\r\n while amount < len(clusters):\r\n amount = len(clusters)\r\n pool = mp.Pool(self.cores)\r\n new_clusters = pool.starmap(recluster,\r\n zip(clusters, repeat(min_size), repeat(self.guard), repeat(self.function)))\r\n pool.close()\r\n pool.join()\r\n clusters = new_clusters\r\n temp = []\r\n for cluster in clusters:\r\n if isinstance(cluster, Cluster):\r\n temp.append(cluster)\r\n else:\r\n temp += cluster\r\n clusters = temp\r\n return clusters","def construct_kdtree_data(points, max_level=-1, calc_split_positions=False):\n assert points.ndim == 2, 'points.ndim must be 2, got points with shape {}'\\\n .format(points.shape)\n num_point = points.shape[0]\n if max_level <= -1:\n max_level = calc_max_level(num_point)\n # print('max_level', max_level, 'num_point', num_point)\n target_size = 2 ** max_level\n if target_size > num_point:\n # augment point to make power of 2\n remainder = target_size - num_point\n print('[DEBUG] add points, target_size={}, remainder={}'\n .format(target_size, remainder))\n # select remainder randomly\n inds = numpy.random.choice(range(num_point), remainder)\n inds = numpy.concatenate([numpy.arange(len(points)), inds], axis=0)\n points = points[inds]\n elif target_size < num_point:\n # Reduce number of points\n inds = numpy.random.permutation(num_point)[:target_size]\n points = points[inds]\n else:\n inds = numpy.arange(num_point)\n assert points.shape[0] == target_size\n kdtree = scipy.spatial.cKDTree(points, leafsize=1, balanced_tree=True)\n tree = kdtree.tree\n # split_dims[i] will store `split_dim` for the level `i`.\n split_dims = [[] for _ in range(max_level)]\n if calc_split_positions:\n split_positions = [[] for _ in range(max_level)]\n else:\n split_positions = None\n _parse_split_dims(tree, split_dims, max_level=max_level,\n split_positions=split_positions)\n split_dims = numpy.array([numpy.array(elem) for elem in split_dims])\n\n if split_positions is not None:\n # convert list to numpy array with object type.\n split_positions = numpy.array(\n [numpy.array(elem) for elem in split_positions])\n return points[tree.indices], split_dims, inds[tree.indices], kdtree, split_positions","def ddds(cloud, sample_size, presample=None, processes=10):\n\n #--------------------------------------------------------------------------\n\n ### Prep\n\n # Handle small point clouds\n if cloud.shape[0] <= sample_size:\n warn(\"(code 1) Point cloud is already <= desired sample size. \" +\n \"No subsampling is performed.\")\n return cloud\n\n\n #--------------------------------------------------------------------------\n\n ### Compute per-landmark local densities\n\n # Subsample randomly (for speed/memory efficiency)\n if presample is not None:\n cloud_presubs = random_subsample(cloud, presample)\n else:\n cloud_presubs = np.copy(cloud)\n\n # Compute distance of each subsampled point to the closest other point\n # Note: `k=2` is necessary since `k=1` is the point itself.\n tree = cKDTree(cloud)\n NN_dists = tree.query(cloud_presubs, k=2, n_jobs=processes)[0][:,1]\n\n # Get the size of the local neighborhood\n # which is `alpha * median(smallest_distances)`,\n # where a good value for alpha is 5 according to SPADE\n alpha = 5\n NN_size = alpha * np.median(NN_dists)\n\n # Get the local density (LD) of each landmark\n # ...which is the number of other landmarks in its local neighborhood\n LDs = tree.query_ball_point(cloud, NN_size, n_jobs=processes) # Get indices\n LDs = np.vectorize(len)(LDs) # Count\n\n # Define the target density (TD)\n # Note: Good values according to SPADE: the 3rd or 5th percentile of LDs\n # Note: This effectively defines how strongly the data will be subsampled\n TD_percentile = 3\n TD = np.percentile(LDs, TD_percentile)\n\n\n #--------------------------------------------------------------------------\n\n ### Perform density-dependent subsampling\n\n # Create p(keep_lm) probability vector\n # Note: For each point i, the probability of keeping it is\n # { 1 if LD_i < TD\n # { TD / LD_i otherwise\n p_keep = TD / LDs\n p_keep[LDs<TD] = 1\n\n # Randomly decide if a landmark should be kept according to p(keep_lm)\n rand = np.random.uniform(size=cloud.shape[0])\n keep = p_keep >= rand\n\n # Index the lms to be kept\n cloud_ddds = cloud[keep,:]\n\n\n #--------------------------------------------------------------------------\n\n ### Further random downsampling\n\n # Note: This ensures that the downsampled cloud does not grow with the\n # input data and instead is of the specified sample_size or smaller.\n\n if cloud_ddds.shape[0] > sample_size:\n cloud_ddds = random_subsample(cloud_ddds, sample_size)\n\n #--------------------------------------------------------------------------\n\n ### Return result\n return cloud_ddds","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def generate_threat_kde_dataset(train_dataset):\n\n threat_grid_cells = train_dataset['X'][~train_dataset['Y']]\n kde_values = threat_grid_cells[['latitude_index', 'longitude_index', 'KDE']]\n\n threat_kde_df = kde_values.set_index(['latitude_index', 'longitude_index'])['KDE']\n threat_kde_df = threat_kde_df.sort_values(ascending=False)\n\n return list(threat_kde_df.index), threat_kde_df","def update(self, data: np.ndarray, centroids: List[np.ndarray]) -> Tuple[List[np.ndarray], List[List[np.ndarray]]]:\n _num, L = data.shape\n clusters = [np.empty((0, L))] * self.k\n for d in data:\n cluster_id = np.apply_along_axis(lambda cent: self.distance(d, cent), axis=1, arr=centroids).argmin()\n clusters[cluster_id] = np.append(clusters[cluster_id], d.reshape(1, 256), axis=0)\n\n new_centroids = np.empty_like(centroids)\n for i, cluster in enumerate(clusters):\n new_centroids[i] = self.median(cluster)\n\n return (new_centroids, clusters)","def private_center_recovery(\n raw_data,\n cluster_assignment,\n norm,\n epsilon,\n delta,\n):\n\n cluster_ids = np.unique(cluster_assignment)\n _, d = raw_data.shape\n centers = []\n for _ in range(max(cluster_ids) + 1):\n centers.append(np.zeros(d))\n\n for c_id in cluster_ids:\n points = raw_data[c_id == cluster_assignment]\n if np.size(points) == 0:\n centers[c_id] = np.random.uniform(-norm, norm)\n centers[c_id] = private_centers(points, norm, epsilon, delta)\n return np.vstack(centers)","def euclidean_cluster_extract(points, tolerance=2, min_cluster_size=20, max_cluster_size=25000):\n filtered_points = pclpy.pcl.segmentation.EuclideanClusterExtraction.PointXYZ()\n kd_tree = pclpy.pcl.search.KdTree.PointXYZ()\n points_to_cluster = pclpy.pcl.PointCloud.PointXYZ(points)\n \n kd_tree.setInputCloud(points_to_cluster)\n filtered_points.setInputCloud(points_to_cluster)\n filtered_points.setClusterTolerance(tolerance)\n filtered_points.setMinClusterSize(min_cluster_size)\n filtered_points.setMaxClusterSize(max_cluster_size)\n filtered_points.setSearchMethod(kd_tree)\n\n point_indexes = pclpy.pcl.vectors.PointIndices()\n filtered_points.extract(point_indexes)\n\n cluster_list = [points_to_cluster.xyz[i2.indices] for i2 in point_indexes]\n return cluster_list","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def cf_to_points(ds: xr.Dataset):\n from shapely.geometry import MultiPoint, Point\n\n # Shorthand for convenience\n geo = ds.geometry_container.attrs\n\n # The features dimension name, defaults to the one of 'node_count' or the dimension of the coordinates, if present.\n feat_dim = None\n if \"coordinates\" in geo and feat_dim is None:\n xcoord_name, _ = geo[\"coordinates\"].split(\" \")\n (feat_dim,) = ds[xcoord_name].dims\n\n x_name, y_name = ds.geometry_container.attrs[\"node_coordinates\"].split(\" \")\n xy = np.stack([ds[x_name].values, ds[y_name].values], axis=-1)\n\n node_count_name = ds.geometry_container.attrs.get(\"node_count\")\n if node_count_name is None:\n # No node_count means all geometries are single points (node_count = 1)\n # And if we had no coordinates, then the dimension defaults to \"features\"\n feat_dim = feat_dim or \"features\"\n node_count = xr.DataArray([1] * xy.shape[0], dims=(feat_dim,))\n if feat_dim in ds.coords:\n node_count = node_count.assign_coords({feat_dim: ds[feat_dim]})\n else:\n node_count = ds[node_count_name]\n\n j = 0 # The index of the first node.\n geoms = np.empty(node_count.shape, dtype=object)\n # i is the feature index, n its number of nodes\n for i, n in enumerate(node_count.values):\n if n == 1:\n geoms[i] = Point(xy[j, :])\n else:\n geoms[i] = MultiPoint(xy[j : j + n, :])\n j += n\n\n return xr.DataArray(geoms, dims=node_count.dims, coords=node_count.coords)","def calcClusters(dataset, medoids, number_of_clusters, verbosity=0, class_header=\"Class\"):\n clusters = [pandas.DataFrame(columns=dataset.columns)] * number_of_clusters # create array of clusters\n multiprocess_count = multiprocessing.cpu_count() # Find processor count\n pool = multiprocessing.Pool(processes=multiprocess_count) # create multiprocessing pool\n\n set_list = []\n partition_size = math.ceil(len(dataset) / multiprocess_count)\n for i in range(multiprocess_count - 1): # repeat for every subset\n sample = dataset.iloc[i * partition_size: (i + 1) * partition_size] # take a sample of data\n set_list.append((sample, medoids, number_of_clusters, verbosity, class_header)) # fill work list\n set_list.append(\n (dataset.iloc[(multiprocess_count - 1) * partition_size:], medoids, number_of_clusters, verbosity, class_header))\n\n # find list of clustering for each subset\n clusters_subsets = pool.starmap(Cluster.calcClustersMultiprocess, set_list)\n pool.close()\n pool.join()\n # Transpose 2d list of dataframes so each lower level list is of the same cluster\n cluster_lists = [[i for i in element if i is not None] for element in list(zip_longest(*clusters_subsets))]\n\n for i in range(number_of_clusters): # concat together each list of cluster subsets.\n clusters[i] = pandas.concat(cluster_lists[i])\n return clusters","def create_gaussian_data(self, mean, std, nPoints, nClusters, nDimension):\n dataset = np.zeros((nClusters, nPoints, nDimension), dtype=float)\n for i in range(nClusters):\n cov = std[i] ** 2\n dataset[i, :, :] = np.random.multivariate_normal(mean[i], cov, nPoints)\n\n return dataset","def kmeans(self, dims, k):\n points = self.get_points(*dims)\n from mlabwrap import mlab\n idx = mlab.kmeans(points, k, nout=1)\n \n # we need to convert the index array from matlab to python (and remember\n # that python is 0-based and not 1-based)\n idx = idx.astype('int')\n \n new_data = self.data[idx]\n tables = [DataTable(\n self.data[idx==(i+1)],\n self.dims,\n self.legends,\n self.tags,\n self.sub_name('kmeans cluster %d' % i)) for i in xrange(k)]\n #for t in tables:\n # t.properties['original_table'] = self\n return tables","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def _distribute_data_to_cluster(self):\n\n for data in self.data:\n _distances = self._calculate_distances(data)\n _cluster = self._get_closest_cluster(_distances)\n self.clusters[_cluster].append(data)","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def density_based_cluster(R, clusters):\n c_points = {}\n i = 0\n for cluster in clusters:\n points = set()\n for attr in cluster:\n for point in R[attr]:\n points.add(point)\n c_points[i] = points\n i += 1\n return c_points","def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\r\n ds_arr_ones = []\r\n for clus in SOM_clusters_block:\r\n node_cluster_set_test = [clus]\r\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\r\n #calculate the blocked days which the new cluster determines\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\r\n #calculate precision, recall and F1\r\n if len(str(node_cluster_set_test)) == 1:\r\n comb_str = f\"{node_cluster_set_test[0]}\".replace(\"'\", \"\")\r\n else:\r\n comb_str = f\"{str(node_cluster_set_test)[1:-1]}\".replace(\"'\", \"\") \r\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\r\n ds_arr_ones.append(ds)\r\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \"set\")\r\n return blocks_one_clusnum","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def diameter_clustering_vs_prob_ws(num_nodes, k):\r\n xdata = []\r\n ydata = []\r\n zdata = []\r\n prob = 0.0005\r\n while prob < 1:\r\n xdata += [prob]\r\n diameters = []\r\n coeffs = []\r\n for i in range(k):\r\n graph = make_ws_graph(num_nodes, 8, prob)\r\n diameters += [diameter(graph)]\r\n coeffs += [clustering_coefficient(graph)]\r\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\r\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\r\n prob = 1.2*prob\r\n return xdata, ydata, zdata","def run_k_means(self):\r\n centroids = self.centroids\r\n\r\n for i in range(self.max_iters):\r\n self.closestcentroids()\r\n self.newcentroids()\r\n\r\n J = 0\r\n X = self.x\r\n m = len(X)\r\n idx = self.index\r\n K = self.K\r\n dim = X.shape[1]\r\n\r\n for num in range(K):\r\n # find the index of all entries where idx==n\r\n indexentries = np.nonzero(idx == num)[0]\r\n # the values in X that have the index in indesxentries\r\n values = X[indexentries]\r\n # using one of the K centroids to do the calculation. K<=2 doesn't\r\n # work here for some reason.\r\n centroid = centroids[num, 0]\r\n J += np.sum((values - centroid) ** 2)\r\n\r\n return [centroids.reshape((1, K, dim)), [X[idx == k].size for k in range(K)], J / m]","def get_clusters(nombre):\n lon, lat = mydic[nombre][\"lon\"], mydic[nombre][\"lat\"]\n scaled_lon = scaler_lon.transform(np.array(lon).reshape(-1, 1))\n scaled_lat = scaler_lat.transform(np.array(lat).reshape(-1, 1))\n clusters = kmeans.predict(\n pd.DataFrame({\"x\": [l for l in scaled_lat], \"y\": [l for l in scaled_lon]})\n )\n return clusters","def calcClustersMultiprocess(dataset, medoids, number_of_clusters, verbosity=0, class_header=\"Class\"):\n clusters = [pandas.DataFrame(columns=dataset.columns)] * number_of_clusters # create array of clusters\n for _, datum in dataset.iterrows(): # For every datum\n nearest_medoid_index = 0\n nearest_medoid = next(medoids.iterrows())[1]\n shortest_distance = Cluster.calcDistance(datum, nearest_medoid,\n class_header=class_header) # Find nearest medoid\n for medoid_row_index, medoid_tuple in enumerate(medoids.iterrows()):\n medoid_frame_index = medoid_tuple[0] # Find nearest medoid\n medoid = medoid_tuple[1]\n if medoid_row_index is 0: continue\n distance = Cluster.calcDistance(datum, medoid,\n class_header=class_header) # find distance to current medoid\n if verbosity >= 2:\n print(\"DISTANCE TO\", medoid_frame_index)\n print(distance)\n print(\"MEDOID INDEX\")\n print(medoid_row_index)\n\n if distance < shortest_distance: # if current medoid is closer than all previous select it\n shortest_distance = distance\n nearest_medoid_index = medoid_row_index\n\n if verbosity >= 3:\n print(\"ITERROW DATUM\")\n print(datum)\n print(\"DATAFRAME ARRAY CLUSTERS\")\n print(clusters)\n\n # Assign datum to appropriate cluster\n clusters[nearest_medoid_index] = clusters[nearest_medoid_index].append(datum)\n return clusters","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def generate_clusters(self, medoids, samples):\n clusters = []\n for i in range(0, medoids.shape[0]):\n clusters.append([])\n for currentSampleIndex in range(0, samples.shape[0]):\n currentSample = samples[currentSampleIndex]\n minDistance = np.inf\n minDistanceIndex = 0\n for currentMedoidIndex in range(0, medoids.shape[0]):\n currentDistance = distance.euclidean(currentSample, medoids[currentMedoidIndex])\n if (currentDistance < minDistance):\n minDistance = currentDistance\n minDistanceIndex = currentMedoidIndex\n clusters[minDistanceIndex].append(currentSample)\n return clusters\n pass","def make_points(self, npts, xbest, sigma, subset=None, proj_fun=None,\n merit=candidate_merit_weighted_distance):\n\n new_points = np.zeros((npts, self.data.dim))\n for i in range(npts):\n new_points[i, :] = CandidateDYCORS.make_points(self, npts=1, xbest=xbest, sigma=0.2,\n subset=subset, proj_fun=proj_fun)\n return new_points","def clusters(self):\n raise NotImplementedError","def Dist_clust(data):\n mask = np.loadtxt('/net/tarea/scratch/Rafael/phd/apogee/python/comb_SkyTel_mask.dat')\n masked = np.where(mask == 1)[0]\n spectra_list = data['fullset']\n clusters = data['clusters']\n clusters = clusters.transpose()\n distance = np.zeros((len(spectra_list), 2))\n min_dist_cl = np.zeros((data['nc'], 2))\n for j_cluster in range(data['nc']):\n dist_cluster= np.zeros((data['nc']))\n for i_cluster in range(data['nc']):\n dist_cluster[i_cluster] = np.nansum((clusters[j_cluster][masked] - clusters[i_cluster][masked])**2)**0.5\n min_dist_cl[j_cluster,0] = np.argmin(dist_cluster)\n dist_cluster[np.argmin(dist_cluster)] = dist_cluster[np.argmax(dist_cluster)]\n if (len(np.where(dist_cluster != 0)[0]) > 0):\n min_dist_cl[j_cluster,1] = np.argmin(dist_cluster[(dist_cluster != 0)])\n for i_spec, name in enumerate(spectra_list):\n vec_temp = np.load(name)\n for i_cluster, j_cluster in enumerate(min_dist_cl[data['assign'][i_spec]]):\n distance[i_spec,i_cluster] = np.nansum((clusters[j_cluster][masked] - vec_temp['norm'][masked])**2)**0.5\n vec_temp.close()\n return distance, min_dist_cl","def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\n res = []\n for n_clusters in n_clusters_considered:\n res.append([])\n for _ in range(n_repeats):\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\n print(X.val.shape)\n print(X_restricted.val.shape)\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\n res[-1].append(evaluator_X.weighted_average) \n return res","def getCluster(self, eps = None, minPts = None):\n #D = getDistanceMatrix()\n #print(\"Distance matrix completed, clustering in process\")\n clusters = DBSCAN(metric=Categorization.cosin_sim_pairs).fit_predict(np.arange(186696).reshape(-1, 1))\n print(\"Clustering completed, writing pickle file\")\n self.writeFile(clusters, \"clusters.pickle\")\n return clusters","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def create_cluster(df,validate, test, X, k, name):\n \n scaler = StandardScaler(copy=True).fit(df[X])\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\n kmeans = KMeans(n_clusters = k, random_state = 42)\n kmeans.fit(X_scaled)\n kmeans.predict(X_scaled)\n df[name] = kmeans.predict(X_scaled)\n df[name] = 'cluster_' + df[name].astype(str)\n \n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\n validate[name] = kmeans.predict(v_scaled)\n validate[name] = 'cluster_' + validate[name].astype(str)\n \n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\n test[name] = kmeans.predict(t_scaled)\n test[name] = 'cluster_' + test[name].astype(str)\n \n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\n return df, X_scaled, scaler, kmeans, centroids","def cluster_dist(self):\n clusters = self.all_clusters()\n lengths = [len(cluster) for cluster in clusters]\n d = Dist(lengths)\n d.plot_ccdf(loglog)\n show()","def cluster_center_update_dataset(spn, dataset):\n\n if isinstance(spn, Categorical):\n\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, IdentityNumericLeaf):\n\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, Sum):\n cc = spn.cluster_centers\n\n node_idx = 0\n\n min_dist = np.inf\n min_idx = -1\n for n in spn.children:\n # distance calculation between the dataset and the different clusters\n # (there exist a much faster version on scipy)\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\n #\n proj = projection(dataset, n.scope)\n dist = distance.euclidean(cc[node_idx], proj)\n if dist < min_dist:\n min_dist = dist\n min_idx = node_idx\n\n node_idx += 1\n assert min_idx > -1\n assert min_idx < len(spn.children)\n adapt_weights(spn, min_idx)\n cluster_center_update_dataset(spn.children[min_idx], dataset)\n elif isinstance(spn, Product):\n\n for n in spn.children:\n cluster_center_update_dataset(n, dataset)\n else:\n raise Exception(\"Invalid node type \" + str(type(spn)))\n spn.cardinality += 1","def cluster_data(attrs):\n if projection_exists(attrs):\n df = load_df()\n X = load_X()\n else:\n X, df = get_projection(attrs)\n\n # Execute clustering\n model = cluster_algorithms[attrs['algorithm']](X, attrs)\n labels = model.labels_ \\\n if hasattr(model, 'labels_') \\\n else model.predict(X)\n\n # Save clusters for tfidf and similar\n df['clx_cluster'] = labels\n\n save_df(df)\n save_cluster_model(model)\n return scatterplot(X, labels, df['clx_id'])","def generate_queries(DIMS,t,data):\n #Start With clusters\n x = np.linspace(0,1,6)\n a = [x.tolist()]*DIMS\n #Define cluster centers and covariance matrix\n cluster_centers = list(itertools.product(*a))\n cov = np.identity(DIMS)*0.2\n logger.debug(\"Generating queries at %d cluster centers\" % len(cluster_centers))\n query_centers = []\n #Generate queries over cluster centers\n for c in cluster_centers:\n queries = np.random.multivariate_normal(np.array(c), cov, size=50)\n query_centers.append(queries)\n query_centers = np.array(query_centers).reshape(-1,DIMS)\n \n ranges = np.random.uniform(low=0.03**(1/DIMS), high=0.15**(1/DIMS), size=(query_centers.shape[0], 1))\n ranges = np.ones((query_centers.shape[0], DIMS))*ranges\n assert(ranges.shape[0]==query_centers.shape[0])\n queries = []\n i=0\n logger.debug(\"Query Generation\")\n for q,r in zip(query_centers,ranges):\n b = generate_boolean_vector(data,q,r,DIMS)\n if t=='density':\n qt = q.tolist()\n qt += r.tolist()\n qt.append(execute_query_dens(b,data))\n queries.append(qt)\n elif t=='aggr':\n qt = q.tolist()\n qt += r.tolist()\n qt.append(execute_query_aggr(b,data))\n queries.append(qt)\n i+=1\n logger.debug(\"Generated {0} queries\".format(len(queries)))\n return queries","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def fiedler_clustering(self, num_clusters):\n\n clusters = MiniBatchKMeans(n_clusters=num_clusters).fit_predict(self.graph)\n\n return clusters","def Datacenters(self):\n if not self._datacenters:\n dcs = self._get_objects(vim.Datacenter)\n for dc in dcs:\n self._datacenters[dc.name] = dc\n return self._datacenters","def extract_clusters (points, labels):\n assert_points_2d (points)\n assert_labels (labels)\n\n id_label_pairs = list (enumerate (set (labels.flatten ())))\n labels_map = dict ([(v, i) for (i, v) in id_label_pairs])\n \n # Count how many points belong to each cluster\n counts = [0] * len (labels_map)\n for l in labels.flatten ():\n counts[labels_map[l]] += 1\n \n # Allocate space for each cluster\n clusters = [np.zeros ((k, 3)) for k in counts]\n \n # Separate the points by cluster\n counts = [0] * len (labels_map)\n for (x, l) in zip (points, labels.flatten ()):\n l_id = labels_map[l]\n k = counts[l_id]\n clusters[l_id][k, :] = x\n counts[l_id] += 1\n \n # Generate cluster labels\n cluster_labels = [None] * len (labels_map)\n for (l, i) in labels_map.items ():\n cluster_labels[i] = l\n \n return (clusters, cluster_labels)","def createInputPointCloud(side_size:int, center_x:int, center_y:int, nb_pts:int):\n in_pts = np.zeros(shape=(nb_pts,2), dtype=np.float32)\n side_nb_pts = nb_pts / 4\n ds = side_size / side_nb_pts\n for i in range(nb_pts):\n if i < side_nb_pts:\n in_pts[i][0] = center_x + i * ds - side_size * 0.5\n in_pts[i][1] = center_y + side_size / 2\n elif i < 2 * side_nb_pts:\n in_pts[i][0] = center_x + side_size / 2\n in_pts[i][1] = center_y + (i - 1*side_nb_pts) * ds - side_size * 0.5\n elif i < 3 * side_nb_pts:\n in_pts[i][0] = center_x + (i - 2*side_nb_pts) * ds - side_size * 0.5\n in_pts[i][1] = center_y - side_size / 2\n else:\n in_pts[i][0] = center_x - side_size / 2\n in_pts[i][1] = center_y + (i - 3*side_nb_pts) * ds - side_size * 0.5\n return in_pts","def dictionary(descriptors, n_clusters):\n # TODO\n print(descriptors.shape)\n dummy=MiniBatchKMeans(n_clusters=n_clusters, batch_size=3000, random_state=9).fit(descriptors)\n clusters=dummy.cluster_centers_\n return clusters","def calculate_distances(data_point, centroids):\n distances = []\n for centroid_index, centroid_value in enumerate(centroids):\n distances.append(distance(data_point, centroid_value))\n return distances","def point_dists(base_sets,new_sets):\n res = np.zeros(new_sets.shape[0])\n for ix in range(len(res)):\n diffs = base_sets[:]-new_sets[ix]\n dists = np.sum(np.square(diffs),axis=-1)\n maxd = np.max(dists,axis=-1) \n res[ix] = np.min(maxd)\n return res","def calc_final_clusters(sp_initial, km_initial):\r\n sp_final = kc.kmeans(T.tolist(), sp_initial, k, n, k, MAX_ITER)\r\n km_final = kc.kmeans(data.tolist(), km_initial, k, n, d, MAX_ITER)\r\n if km_final is None or sp_final is None:\r\n exit(1)\r\n spectral_clusters = np.array(sp_final)\r\n kmeans_clusters = np.array(km_final)\r\n\r\n return spectral_clusters, kmeans_clusters","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])"],"string":"[\n \"def _create_constrained_dataset(centers, delta, size):\\n dataset = []\\n count = 0\\n for i, c in enumerate(centers):\\n for j in range(size):\\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\\n direction = x / np.linalg.norm(x)\\n magnitude = np.random.uniform(0.0, 0.5 * delta)\\n # magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED\\n dataset.append((c + magnitude * direction, i, count))\\n count += 1\\n return dataset\",\n \"def get_clusters(self,points):\\n self.points = points\\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\\n ##self.hull = \\n return self.__dabest\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\\n\\n # generate clusters of blobs\\n generated_points_x, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_x,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n generated_points_y, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_y,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n # remove decimals\\n generated_points_x = generated_points_x.astype(\\\"int\\\")\\n generated_points_y = generated_points_y.astype(\\\"int\\\")\\n\\n ind_delete = np.logical_or.reduce(\\n (\\n generated_points_x < 0,\\n generated_points_y < 0,\\n generated_points_x > xsize - 1,\\n generated_points_y > ysize - 1,\\n ),\\n )\\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n\\n return generated_points_x, generated_points_y\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def calculate_all_distances_to_center(self):\\n all_distances = pd.DataFrame()\\n for label in np.unique(self.embedding_df['cluster']): \\n distance_df = self.calculate_distances_for_cluster(label)\\n all_distances = pd.concat([all_distances, distance_df])\\n \\n self.embedding_df = self.embedding_df.merge(all_distances, left_index=True, right_index=True)\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def prepare_data_for_d(self):\\n\\n center_nodes = []\\n neighbor_nodes = []\\n labels = []\\n for i in self.root_nodes:\\n if np.random.rand() < config.update_ratio:\\n # self.graph[i] = [neighbors of i]\\n pos = self.graph[i]\\n neg, _ = self.sample(i, self.trees[i], len(pos), for_d=True)\\n # print(\\\"tree_i_d: \\\", self.trees[i])\\n # print(\\\"neg_samples: \\\", neg)\\n # print(\\\"neg is: \\\", neg)\\n if len(pos) != 0 and neg is not None:\\n # positive samples\\n center_nodes.extend([i] * len(pos))\\n neighbor_nodes.extend(pos)\\n labels.extend([1] * len(pos))\\n\\n # negative samples\\n center_nodes.extend([i] * len(pos))\\n neighbor_nodes.extend(neg)\\n labels.extend([0] * len(neg))\\n # print(\\\"cen: \\\", center_nodes)\\n return center_nodes, neighbor_nodes, labels\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def generate_clusters(df):\\n\\n df_size = df.shape[0]\\n print(df_size)\\n n_clusters = 0\\n percent_min_pts = 0.105\\n min_clusters = 3\\n while (n_clusters != min_clusters):\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n min_cluster_pts = math.floor(df_size * percent_min_pts)\\n print(\\\"min_cluster_pts\\\", min_cluster_pts)\\n\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\\n print(df.head())\\n clusterer.fit(df)\\n cluster_groups = {}\\n labels = clusterer.labels_\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n n_clusters = len(set(labels))\\n print(\\\"n_clusters\\\", n_clusters)\\n multiplier = abs(n_clusters - min_clusters) * 0.001\\n print(\\\"multiplier\\\", multiplier)\\n if n_clusters > min_clusters:\\n percent_min_pts += multiplier\\n else:\\n percent_min_pts -= multiplier\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n return labels\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def assign_points(data, centers):\\n result = {c: [] for c in centers}\\n for point in data:\\n min_distance = float(\\\"inf\\\")\\n for c in centers:\\n dist = euclidean_distance(point, c)\\n if dist < min_distance:\\n min_distance = dist\\n min_center = c\\n result[min_center].append(point)\\n\\n return result\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\\n self.n = n\\n self.d = d\\n\\n # 95% of data lies in a 2*sigma ball around the mean.\\n # For unit variance normal, the 2*sigma ball mean the centers\\n # should be at distance of 4 in the d dimensional space.\\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\\n cov = np.eye(d)\\n\\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\\n # print(dist_mean)\\n # cov = np.eye(d)\\n\\n frac = int(1 / pos_fraction)\\n\\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\\n\\n self.X = np.vstack((cluster1, cluster2))\\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\\n\\n # Make blobs\\n # if True:\\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def create_dataset(n_clusters, n_dim, n_samples, mean=None, std=None, seed=None):\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if mean is None:\\n means = [np.random.randint(-(i + 1), (i + 1),\\n n_dim).astype(np.float32) for i in range(n_clusters)]\\n if std is None:\\n stds = []\\n for _ in range(n_clusters):\\n a = np.diag(random.rand(n_dim))\\n stds.append(a)\\n\\n data_set = []\\n cluster_id = []\\n for i, mean, std in zip(range(n_clusters), means, stds):\\n data_set.append(np.random.multivariate_normal(mean, std, n_samples))\\n cluster_id.append(np.ones(n_samples) * i)\\n\\n data_set = np.concatenate(data_set)\\n cluster_id = np.concatenate(cluster_id)\\n sample_idx = np.random.choice(data_set.shape[0], n_samples, replace=False)\\n\\n # Return correct amount of samples\\n return data_set[sample_idx, :], cluster_id[sample_idx]\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def kMeans(d, k):\\n #First get the random centroids from the data\\n newCentroids = getRandomCentroids(d, k)\\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\\n\\n #Get the clusters from these random centroids\\n clusters = initiateCentroid(d, newCentroids, k)\\n oldCentroids = []\\n\\n counter = 0\\n #While the old centroids are not equal to the new ones\\n while oldCentroids != newCentroids:\\n #old is equal to new\\n oldCentroids = newCentroids\\n #Calculate the new centroids\\n k, newCentroids = calcCentroids(d, clusters)\\n #Calculate the new clusters\\n clusters = initiateCentroid(d, newCentroids, k)\\n #Count how many iterations\\n counter += 1\\n\\n return counter, clusters\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def assign_points(data_points, centers):\\n assignments = []\\n for point in data_points:\\n shortest = 10000 # positive infinity\\n shortest_index = 0\\n for i in range(len(centers)):\\n val = distance(point, centers[i])\\n if val < shortest:\\n shortest = val\\n shortest_index = i\\n assignments.append(shortest_index)\\n return assignments\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def generate_clusters_n(df, tweet_deleted):\\n # cluster_labels, n_clusters = dbscan(normalised_df, true_labels, 0.25, 30)\\n # print(\\\"normalised_df.head()\\\", normalised_df.head())\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=10)\\n clusterer.fit(df)\\n labels = clusterer.labels_\\n cluster_groups = {}\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n df[\\\"cluster\\\"] = labels\\n df[\\\"tweet_deleted\\\"] = tweet_deleted\\n cluster_results = list()\\n for cluster_no in cluster_groups.keys():\\n print(\\\"++++++++++\\\")\\n print(\\\"cluster_no\\\", cluster_no)\\n cluster_result = list()\\n cluster_result.append(cluster_no)\\n\\n cluster = df.mask('cluster', cluster_no)\\n print(cluster_no, \\\" :\\\")\\n tweet_deleted = cluster.mask('tweet_deleted', True).shape[0]\\n not_tweet_deleted = cluster.mask('tweet_deleted', False).shape[0]\\n print(\\\"deleted_df len:\\\", tweet_deleted)\\n print(\\\"not_deleted_df len:\\\", not_tweet_deleted)\",\n \"def initiateCentroid(data_points, centroids, k):\\n #Create empty list in list (amount is k)\\n AvgCentroids = [[] for i in range(k)]\\n\\n #For each datapoint in all datapoints\\n for dp in data_points:\\n dis = []\\n #For each centroid in centroids\\n for c in range(len(centroids)):\\n #Calculate the euclidean distance between those points and append\\n #to distance list\\n dis.append(calcEuclideanDistance(dp, centroids[c]))\\n \\n #Get the smallest value of the list and the index\\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\\n\\n #The index of the smallest value is the index where it will be added\\n #to the avgCentroids list. So it represents the number of the cluster\\n AvgCentroids[idx].append(dp)\\n \\n return AvgCentroids\",\n \"def generate_k(data_set, k):\\n centers = []\\n dimensions = len(data_set[0])\\n min_max = defaultdict(int)\\n\\n for point in data_set:\\n for i in range(dimensions):\\n val = point[i]\\n min_key = 'min_{0}d'.format(i)\\n max_key = 'max_{0}d'.format(i)\\n if min_key not in min_max or val < min_max[min_key]:\\n min_max[min_key] = val\\n if max_key not in min_max or val > min_max[max_key]:\\n min_max[max_key] = val\\n\\n for _k in range(k):\\n rand_point = []\\n for i in range(dimensions):\\n min_val = min_max['min_{0}d'.format(i)]\\n max_val = min_max['max_{0}d'.format(i)]\\n \\n rand_point.append(uniform(min_val, max_val))\\n centers.append(rand_point)\\n return centers\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def get_disc_data_sets(sample_size):\\n log.info(\\\"MAKING DATA SETS\\\")\\n\\n fakes = generate_fakes(int(sample_size / 2))\\n reals = get_reals(int(sample_size / 2))\\n total = numpy.concatenate((reals, fakes))\\n real_labels = numpy.ones([len(reals)])\\n fake_labels = numpy.zeros([len(fakes)])\\n total_labels = numpy.concatenate((real_labels, fake_labels))\\n return get_discriminator_splits(total, total_labels)\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def run(self, points, K):\\n # Get size\\n D, N = points.shape\\n\\n # DxK array initialiezd with random points\\n centroids = points[:, np.random.permutation(N)[:K]]\\n\\n # Assigments 1xN array\\n labels = np.zeros(N)\\n\\n for it in np.arange(self.niter):\\n # 1. Compute distance to all cluster\\n #v1 dirty\\n distances = np.zeros([K, N])\\n for n in np.arange(N):\\n for k in np.arange(K):\\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \\n\\n # 2. Update assigments\\n # v1 dirty\\n for n in np.arange(N):\\n kmin = 0\\n for k in np.arange(1, K):\\n if distances[k, n] <= distances[kmin, n]:\\n kmin = k\\n labels[n] = kmin\\n # v2 quicker\\n #labels = np.argmin(distances, axis=1)\\n\\n # 3. Update mean\\n for k in np.arange(K):\\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\\n\\n return centroids, labels\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def dbscan(dataList, maxClusterNum, eps, minPts):\\n unvisitedPt = list(dataList)\\n clusterSizeList = []\\n clusterSeedList = []\\n lastClusterID = 0\\n # lookup all unvisited Points\\n while (len(unvisitedPt) != 0):\\n idx = randint(0, len(unvisitedPt) - 1)\\n cur = unvisitedPt[idx]\\n cur.isVisited = True\\n del unvisitedPt[idx]\\n\\n # Create new cluster if 'cur' pt. is core object\\n neighborhood = findNeighbor(cur, dataList, eps)\\n if (len(neighborhood) >= minPts):\\n cur.label = lastClusterID\\n clusterSeedList.append(cur)\\n clusterSize = 1\\n idx = -1\\n # find all density-connected points(neighborhood)\\n while (idx < len(neighborhood) - 1):\\n idx += 1\\n if (neighborhood[idx].isVisited):\\n continue\\n neighborhood[idx].isVisited = True\\n unvisitedPt.remove(neighborhood[idx])\\n nextNeighbor = findNeighbor(neighborhood[idx], dataList, eps)\\n if (len(nextNeighbor) >= minPts):\\n # extend neighborhood without duplicate\\n neighborhood = neighborhood \\\\\\n + [x for x in nextNeighbor if x not in neighborhood and not x.isVisited]\\n if (neighborhood[idx].label == -1):\\n neighborhood[idx].label = lastClusterID\\n clusterSize += 1\\n clusterSizeList.append((lastClusterID, clusterSize))\\n lastClusterID += 1\\n\\n # Create labelConverter to remove extra clusters if exist.\\n labelConverter = dict()\\n labelConverter[-1] = -1\\n if (lastClusterID <= maxClusterNum): # no need to remove extra clusters\\n for i in range(maxClusterNum):\\n labelConverter[i] = i\\n else: # create labelConverter that remove extra clusters\\n clusterSizeList.sort(key=itemgetter(1), reverse=True)\\n for i in range(maxClusterNum):\\n labelConverter[clusterSizeList[i][0]] = i\\n for i in range(maxClusterNum, lastClusterID):\\n labelConverter[clusterSizeList[i][0]] = -1\\n # recluster(dataList, labelConverter, clusterSeedList, eps, minPts)\\n return labelConverter\",\n \"def distortion_of_kmeans_clustering(data_table):\\n num_iritations = 5\\n singleton_list = []\\n for line in data_table:\\n singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\\n distortion_list = []\\n for num in range(20, 5, -1):\\n cluster_list = kmeans_clustering(singleton_list,num, num_iritations)\\n distortion = compute_distortion(data_table, cluster_list)\\n distortion_list.append(distortion)\\n return distortion_list\\n\\n#####################################################################\\n# Code to load cancer data, compute a clustering and\\n# visualize the results\\n\\n\\n# def run_example():\\n# \\\"\\\"\\\"\\n# Load a data table, compute a list of clusters and\\n# plot a list of clusters\\n#\\n# Set DESKTOP = True/False to use either matplotlib or simplegui\\n# \\\"\\\"\\\"\\n# data_table = load_data_table(DATA_3108_URL)\\n# singleton_list = []\\n# for line in data_table:\\n# singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4]))\\n num_clusters = 16\\n # cluster_list = sequential_clustering(singleton_list, num_clusters)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"sequential clusters\\\")\\n #\\n # cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, num_clusters)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"hierarchical clusters\\\")\\n #\\n # cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, num_clusters, 5)\\n # print(\\\"Displaying\\\", len(cluster_list), \\\"k-means clusters\\\")\\n\\n # draw the clusters using matplotlib or simplegui\\n #\\n # if DESKTOP:\\n # # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, False)\\n # alg_clusters_matplotlib.plot_clusters(data_table, cluster_list, True) #add cluster centers\\n\\n # else:\\n # alg_clusters_simplegui.PlotClusters(data_table, cluster_list) # use toggle in GUI to add cluster centers\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def gen_clusters(links, posts):\\n\\n clusters = list(iter_clusters(links, posts))\\n return clusters\",\n \"def plotPoints(vec, centers = None, numcolors = 2):\\n\\n try:\\n import matplotlib.pyplot\\n from mpl_toolkits.mplot3d import Axes3D\\n except:\\n raise ImportError, \\\"matplotlib package not found.\\\"\\n\\n markers = ['o', '^', 'x']\\n labels = [\\\"Cluster 1\\\", \\\"Cluster 2\\\", \\\"Morning Data\\\", \\\"Evening Data\\\"]\\n handles = []\\n count = 0\\n \\n fig = matplotlib.pyplot.figure()\\n ax1 = fig.add_subplot(111)\\n\\n for i in range(len(vec)):\\n for v in vec[i]:\\n col = getColor(i, numcolors, decimal = True)\\n col = (0, max(col[1] - 0.2, 0), col[2] - 0.1)\\n ax1.scatter(v[1], v[2], color = col, s = 100, marker = markers[v[0]])\\n\\n matplotlib.pyplot.show()\",\n \"def start_algorithm(self):\\r\\n self.kmeans.set_data(self.tweets)\\r\\n clusters = self.kmeans.start_algorithm()\\r\\n min_size = len(self.tweets) * 0.005\\r\\n if min_size < 50:\\r\\n min_size = 50\\r\\n max_size = len(self.tweets) * 0.20\\r\\n\\r\\n amount = 0\\r\\n\\r\\n while amount < len(clusters):\\r\\n amount = len(clusters)\\r\\n pool = mp.Pool(self.cores)\\r\\n new_clusters = pool.starmap(recluster,\\r\\n zip(clusters, repeat(min_size), repeat(self.guard), repeat(self.function)))\\r\\n pool.close()\\r\\n pool.join()\\r\\n clusters = new_clusters\\r\\n temp = []\\r\\n for cluster in clusters:\\r\\n if isinstance(cluster, Cluster):\\r\\n temp.append(cluster)\\r\\n else:\\r\\n temp += cluster\\r\\n clusters = temp\\r\\n return clusters\",\n \"def construct_kdtree_data(points, max_level=-1, calc_split_positions=False):\\n assert points.ndim == 2, 'points.ndim must be 2, got points with shape {}'\\\\\\n .format(points.shape)\\n num_point = points.shape[0]\\n if max_level <= -1:\\n max_level = calc_max_level(num_point)\\n # print('max_level', max_level, 'num_point', num_point)\\n target_size = 2 ** max_level\\n if target_size > num_point:\\n # augment point to make power of 2\\n remainder = target_size - num_point\\n print('[DEBUG] add points, target_size={}, remainder={}'\\n .format(target_size, remainder))\\n # select remainder randomly\\n inds = numpy.random.choice(range(num_point), remainder)\\n inds = numpy.concatenate([numpy.arange(len(points)), inds], axis=0)\\n points = points[inds]\\n elif target_size < num_point:\\n # Reduce number of points\\n inds = numpy.random.permutation(num_point)[:target_size]\\n points = points[inds]\\n else:\\n inds = numpy.arange(num_point)\\n assert points.shape[0] == target_size\\n kdtree = scipy.spatial.cKDTree(points, leafsize=1, balanced_tree=True)\\n tree = kdtree.tree\\n # split_dims[i] will store `split_dim` for the level `i`.\\n split_dims = [[] for _ in range(max_level)]\\n if calc_split_positions:\\n split_positions = [[] for _ in range(max_level)]\\n else:\\n split_positions = None\\n _parse_split_dims(tree, split_dims, max_level=max_level,\\n split_positions=split_positions)\\n split_dims = numpy.array([numpy.array(elem) for elem in split_dims])\\n\\n if split_positions is not None:\\n # convert list to numpy array with object type.\\n split_positions = numpy.array(\\n [numpy.array(elem) for elem in split_positions])\\n return points[tree.indices], split_dims, inds[tree.indices], kdtree, split_positions\",\n \"def ddds(cloud, sample_size, presample=None, processes=10):\\n\\n #--------------------------------------------------------------------------\\n\\n ### Prep\\n\\n # Handle small point clouds\\n if cloud.shape[0] <= sample_size:\\n warn(\\\"(code 1) Point cloud is already <= desired sample size. \\\" +\\n \\\"No subsampling is performed.\\\")\\n return cloud\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Compute per-landmark local densities\\n\\n # Subsample randomly (for speed/memory efficiency)\\n if presample is not None:\\n cloud_presubs = random_subsample(cloud, presample)\\n else:\\n cloud_presubs = np.copy(cloud)\\n\\n # Compute distance of each subsampled point to the closest other point\\n # Note: `k=2` is necessary since `k=1` is the point itself.\\n tree = cKDTree(cloud)\\n NN_dists = tree.query(cloud_presubs, k=2, n_jobs=processes)[0][:,1]\\n\\n # Get the size of the local neighborhood\\n # which is `alpha * median(smallest_distances)`,\\n # where a good value for alpha is 5 according to SPADE\\n alpha = 5\\n NN_size = alpha * np.median(NN_dists)\\n\\n # Get the local density (LD) of each landmark\\n # ...which is the number of other landmarks in its local neighborhood\\n LDs = tree.query_ball_point(cloud, NN_size, n_jobs=processes) # Get indices\\n LDs = np.vectorize(len)(LDs) # Count\\n\\n # Define the target density (TD)\\n # Note: Good values according to SPADE: the 3rd or 5th percentile of LDs\\n # Note: This effectively defines how strongly the data will be subsampled\\n TD_percentile = 3\\n TD = np.percentile(LDs, TD_percentile)\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Perform density-dependent subsampling\\n\\n # Create p(keep_lm) probability vector\\n # Note: For each point i, the probability of keeping it is\\n # { 1 if LD_i < TD\\n # { TD / LD_i otherwise\\n p_keep = TD / LDs\\n p_keep[LDs<TD] = 1\\n\\n # Randomly decide if a landmark should be kept according to p(keep_lm)\\n rand = np.random.uniform(size=cloud.shape[0])\\n keep = p_keep >= rand\\n\\n # Index the lms to be kept\\n cloud_ddds = cloud[keep,:]\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Further random downsampling\\n\\n # Note: This ensures that the downsampled cloud does not grow with the\\n # input data and instead is of the specified sample_size or smaller.\\n\\n if cloud_ddds.shape[0] > sample_size:\\n cloud_ddds = random_subsample(cloud_ddds, sample_size)\\n\\n #--------------------------------------------------------------------------\\n\\n ### Return result\\n return cloud_ddds\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def generate_threat_kde_dataset(train_dataset):\\n\\n threat_grid_cells = train_dataset['X'][~train_dataset['Y']]\\n kde_values = threat_grid_cells[['latitude_index', 'longitude_index', 'KDE']]\\n\\n threat_kde_df = kde_values.set_index(['latitude_index', 'longitude_index'])['KDE']\\n threat_kde_df = threat_kde_df.sort_values(ascending=False)\\n\\n return list(threat_kde_df.index), threat_kde_df\",\n \"def update(self, data: np.ndarray, centroids: List[np.ndarray]) -> Tuple[List[np.ndarray], List[List[np.ndarray]]]:\\n _num, L = data.shape\\n clusters = [np.empty((0, L))] * self.k\\n for d in data:\\n cluster_id = np.apply_along_axis(lambda cent: self.distance(d, cent), axis=1, arr=centroids).argmin()\\n clusters[cluster_id] = np.append(clusters[cluster_id], d.reshape(1, 256), axis=0)\\n\\n new_centroids = np.empty_like(centroids)\\n for i, cluster in enumerate(clusters):\\n new_centroids[i] = self.median(cluster)\\n\\n return (new_centroids, clusters)\",\n \"def private_center_recovery(\\n raw_data,\\n cluster_assignment,\\n norm,\\n epsilon,\\n delta,\\n):\\n\\n cluster_ids = np.unique(cluster_assignment)\\n _, d = raw_data.shape\\n centers = []\\n for _ in range(max(cluster_ids) + 1):\\n centers.append(np.zeros(d))\\n\\n for c_id in cluster_ids:\\n points = raw_data[c_id == cluster_assignment]\\n if np.size(points) == 0:\\n centers[c_id] = np.random.uniform(-norm, norm)\\n centers[c_id] = private_centers(points, norm, epsilon, delta)\\n return np.vstack(centers)\",\n \"def euclidean_cluster_extract(points, tolerance=2, min_cluster_size=20, max_cluster_size=25000):\\n filtered_points = pclpy.pcl.segmentation.EuclideanClusterExtraction.PointXYZ()\\n kd_tree = pclpy.pcl.search.KdTree.PointXYZ()\\n points_to_cluster = pclpy.pcl.PointCloud.PointXYZ(points)\\n \\n kd_tree.setInputCloud(points_to_cluster)\\n filtered_points.setInputCloud(points_to_cluster)\\n filtered_points.setClusterTolerance(tolerance)\\n filtered_points.setMinClusterSize(min_cluster_size)\\n filtered_points.setMaxClusterSize(max_cluster_size)\\n filtered_points.setSearchMethod(kd_tree)\\n\\n point_indexes = pclpy.pcl.vectors.PointIndices()\\n filtered_points.extract(point_indexes)\\n\\n cluster_list = [points_to_cluster.xyz[i2.indices] for i2 in point_indexes]\\n return cluster_list\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def cf_to_points(ds: xr.Dataset):\\n from shapely.geometry import MultiPoint, Point\\n\\n # Shorthand for convenience\\n geo = ds.geometry_container.attrs\\n\\n # The features dimension name, defaults to the one of 'node_count' or the dimension of the coordinates, if present.\\n feat_dim = None\\n if \\\"coordinates\\\" in geo and feat_dim is None:\\n xcoord_name, _ = geo[\\\"coordinates\\\"].split(\\\" \\\")\\n (feat_dim,) = ds[xcoord_name].dims\\n\\n x_name, y_name = ds.geometry_container.attrs[\\\"node_coordinates\\\"].split(\\\" \\\")\\n xy = np.stack([ds[x_name].values, ds[y_name].values], axis=-1)\\n\\n node_count_name = ds.geometry_container.attrs.get(\\\"node_count\\\")\\n if node_count_name is None:\\n # No node_count means all geometries are single points (node_count = 1)\\n # And if we had no coordinates, then the dimension defaults to \\\"features\\\"\\n feat_dim = feat_dim or \\\"features\\\"\\n node_count = xr.DataArray([1] * xy.shape[0], dims=(feat_dim,))\\n if feat_dim in ds.coords:\\n node_count = node_count.assign_coords({feat_dim: ds[feat_dim]})\\n else:\\n node_count = ds[node_count_name]\\n\\n j = 0 # The index of the first node.\\n geoms = np.empty(node_count.shape, dtype=object)\\n # i is the feature index, n its number of nodes\\n for i, n in enumerate(node_count.values):\\n if n == 1:\\n geoms[i] = Point(xy[j, :])\\n else:\\n geoms[i] = MultiPoint(xy[j : j + n, :])\\n j += n\\n\\n return xr.DataArray(geoms, dims=node_count.dims, coords=node_count.coords)\",\n \"def calcClusters(dataset, medoids, number_of_clusters, verbosity=0, class_header=\\\"Class\\\"):\\n clusters = [pandas.DataFrame(columns=dataset.columns)] * number_of_clusters # create array of clusters\\n multiprocess_count = multiprocessing.cpu_count() # Find processor count\\n pool = multiprocessing.Pool(processes=multiprocess_count) # create multiprocessing pool\\n\\n set_list = []\\n partition_size = math.ceil(len(dataset) / multiprocess_count)\\n for i in range(multiprocess_count - 1): # repeat for every subset\\n sample = dataset.iloc[i * partition_size: (i + 1) * partition_size] # take a sample of data\\n set_list.append((sample, medoids, number_of_clusters, verbosity, class_header)) # fill work list\\n set_list.append(\\n (dataset.iloc[(multiprocess_count - 1) * partition_size:], medoids, number_of_clusters, verbosity, class_header))\\n\\n # find list of clustering for each subset\\n clusters_subsets = pool.starmap(Cluster.calcClustersMultiprocess, set_list)\\n pool.close()\\n pool.join()\\n # Transpose 2d list of dataframes so each lower level list is of the same cluster\\n cluster_lists = [[i for i in element if i is not None] for element in list(zip_longest(*clusters_subsets))]\\n\\n for i in range(number_of_clusters): # concat together each list of cluster subsets.\\n clusters[i] = pandas.concat(cluster_lists[i])\\n return clusters\",\n \"def create_gaussian_data(self, mean, std, nPoints, nClusters, nDimension):\\n dataset = np.zeros((nClusters, nPoints, nDimension), dtype=float)\\n for i in range(nClusters):\\n cov = std[i] ** 2\\n dataset[i, :, :] = np.random.multivariate_normal(mean[i], cov, nPoints)\\n\\n return dataset\",\n \"def kmeans(self, dims, k):\\n points = self.get_points(*dims)\\n from mlabwrap import mlab\\n idx = mlab.kmeans(points, k, nout=1)\\n \\n # we need to convert the index array from matlab to python (and remember\\n # that python is 0-based and not 1-based)\\n idx = idx.astype('int')\\n \\n new_data = self.data[idx]\\n tables = [DataTable(\\n self.data[idx==(i+1)],\\n self.dims,\\n self.legends,\\n self.tags,\\n self.sub_name('kmeans cluster %d' % i)) for i in xrange(k)]\\n #for t in tables:\\n # t.properties['original_table'] = self\\n return tables\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def _distribute_data_to_cluster(self):\\n\\n for data in self.data:\\n _distances = self._calculate_distances(data)\\n _cluster = self._get_closest_cluster(_distances)\\n self.clusters[_cluster].append(data)\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def density_based_cluster(R, clusters):\\n c_points = {}\\n i = 0\\n for cluster in clusters:\\n points = set()\\n for attr in cluster:\\n for point in R[attr]:\\n points.add(point)\\n c_points[i] = points\\n i += 1\\n return c_points\",\n \"def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\\r\\n ds_arr_ones = []\\r\\n for clus in SOM_clusters_block:\\r\\n node_cluster_set_test = [clus]\\r\\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\\r\\n #calculate the blocked days which the new cluster determines\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\\r\\n #calculate precision, recall and F1\\r\\n if len(str(node_cluster_set_test)) == 1:\\r\\n comb_str = f\\\"{node_cluster_set_test[0]}\\\".replace(\\\"'\\\", \\\"\\\")\\r\\n else:\\r\\n comb_str = f\\\"{str(node_cluster_set_test)[1:-1]}\\\".replace(\\\"'\\\", \\\"\\\") \\r\\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\\r\\n ds_arr_ones.append(ds)\\r\\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \\\"set\\\")\\r\\n return blocks_one_clusnum\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def diameter_clustering_vs_prob_ws(num_nodes, k):\\r\\n xdata = []\\r\\n ydata = []\\r\\n zdata = []\\r\\n prob = 0.0005\\r\\n while prob < 1:\\r\\n xdata += [prob]\\r\\n diameters = []\\r\\n coeffs = []\\r\\n for i in range(k):\\r\\n graph = make_ws_graph(num_nodes, 8, prob)\\r\\n diameters += [diameter(graph)]\\r\\n coeffs += [clustering_coefficient(graph)]\\r\\n ydata += [sum(diameters) / k / 19.0] #divide by 19 as this diameter of circle lattice\\r\\n zdata += [sum(coeffs) / k / 0.7] #divide by 0.7 as this is clustering coefficient of circle lattice\\r\\n prob = 1.2*prob\\r\\n return xdata, ydata, zdata\",\n \"def run_k_means(self):\\r\\n centroids = self.centroids\\r\\n\\r\\n for i in range(self.max_iters):\\r\\n self.closestcentroids()\\r\\n self.newcentroids()\\r\\n\\r\\n J = 0\\r\\n X = self.x\\r\\n m = len(X)\\r\\n idx = self.index\\r\\n K = self.K\\r\\n dim = X.shape[1]\\r\\n\\r\\n for num in range(K):\\r\\n # find the index of all entries where idx==n\\r\\n indexentries = np.nonzero(idx == num)[0]\\r\\n # the values in X that have the index in indesxentries\\r\\n values = X[indexentries]\\r\\n # using one of the K centroids to do the calculation. K<=2 doesn't\\r\\n # work here for some reason.\\r\\n centroid = centroids[num, 0]\\r\\n J += np.sum((values - centroid) ** 2)\\r\\n\\r\\n return [centroids.reshape((1, K, dim)), [X[idx == k].size for k in range(K)], J / m]\",\n \"def get_clusters(nombre):\\n lon, lat = mydic[nombre][\\\"lon\\\"], mydic[nombre][\\\"lat\\\"]\\n scaled_lon = scaler_lon.transform(np.array(lon).reshape(-1, 1))\\n scaled_lat = scaler_lat.transform(np.array(lat).reshape(-1, 1))\\n clusters = kmeans.predict(\\n pd.DataFrame({\\\"x\\\": [l for l in scaled_lat], \\\"y\\\": [l for l in scaled_lon]})\\n )\\n return clusters\",\n \"def calcClustersMultiprocess(dataset, medoids, number_of_clusters, verbosity=0, class_header=\\\"Class\\\"):\\n clusters = [pandas.DataFrame(columns=dataset.columns)] * number_of_clusters # create array of clusters\\n for _, datum in dataset.iterrows(): # For every datum\\n nearest_medoid_index = 0\\n nearest_medoid = next(medoids.iterrows())[1]\\n shortest_distance = Cluster.calcDistance(datum, nearest_medoid,\\n class_header=class_header) # Find nearest medoid\\n for medoid_row_index, medoid_tuple in enumerate(medoids.iterrows()):\\n medoid_frame_index = medoid_tuple[0] # Find nearest medoid\\n medoid = medoid_tuple[1]\\n if medoid_row_index is 0: continue\\n distance = Cluster.calcDistance(datum, medoid,\\n class_header=class_header) # find distance to current medoid\\n if verbosity >= 2:\\n print(\\\"DISTANCE TO\\\", medoid_frame_index)\\n print(distance)\\n print(\\\"MEDOID INDEX\\\")\\n print(medoid_row_index)\\n\\n if distance < shortest_distance: # if current medoid is closer than all previous select it\\n shortest_distance = distance\\n nearest_medoid_index = medoid_row_index\\n\\n if verbosity >= 3:\\n print(\\\"ITERROW DATUM\\\")\\n print(datum)\\n print(\\\"DATAFRAME ARRAY CLUSTERS\\\")\\n print(clusters)\\n\\n # Assign datum to appropriate cluster\\n clusters[nearest_medoid_index] = clusters[nearest_medoid_index].append(datum)\\n return clusters\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def generate_clusters(self, medoids, samples):\\n clusters = []\\n for i in range(0, medoids.shape[0]):\\n clusters.append([])\\n for currentSampleIndex in range(0, samples.shape[0]):\\n currentSample = samples[currentSampleIndex]\\n minDistance = np.inf\\n minDistanceIndex = 0\\n for currentMedoidIndex in range(0, medoids.shape[0]):\\n currentDistance = distance.euclidean(currentSample, medoids[currentMedoidIndex])\\n if (currentDistance < minDistance):\\n minDistance = currentDistance\\n minDistanceIndex = currentMedoidIndex\\n clusters[minDistanceIndex].append(currentSample)\\n return clusters\\n pass\",\n \"def make_points(self, npts, xbest, sigma, subset=None, proj_fun=None,\\n merit=candidate_merit_weighted_distance):\\n\\n new_points = np.zeros((npts, self.data.dim))\\n for i in range(npts):\\n new_points[i, :] = CandidateDYCORS.make_points(self, npts=1, xbest=xbest, sigma=0.2,\\n subset=subset, proj_fun=proj_fun)\\n return new_points\",\n \"def clusters(self):\\n raise NotImplementedError\",\n \"def Dist_clust(data):\\n mask = np.loadtxt('/net/tarea/scratch/Rafael/phd/apogee/python/comb_SkyTel_mask.dat')\\n masked = np.where(mask == 1)[0]\\n spectra_list = data['fullset']\\n clusters = data['clusters']\\n clusters = clusters.transpose()\\n distance = np.zeros((len(spectra_list), 2))\\n min_dist_cl = np.zeros((data['nc'], 2))\\n for j_cluster in range(data['nc']):\\n dist_cluster= np.zeros((data['nc']))\\n for i_cluster in range(data['nc']):\\n dist_cluster[i_cluster] = np.nansum((clusters[j_cluster][masked] - clusters[i_cluster][masked])**2)**0.5\\n min_dist_cl[j_cluster,0] = np.argmin(dist_cluster)\\n dist_cluster[np.argmin(dist_cluster)] = dist_cluster[np.argmax(dist_cluster)]\\n if (len(np.where(dist_cluster != 0)[0]) > 0):\\n min_dist_cl[j_cluster,1] = np.argmin(dist_cluster[(dist_cluster != 0)])\\n for i_spec, name in enumerate(spectra_list):\\n vec_temp = np.load(name)\\n for i_cluster, j_cluster in enumerate(min_dist_cl[data['assign'][i_spec]]):\\n distance[i_spec,i_cluster] = np.nansum((clusters[j_cluster][masked] - vec_temp['norm'][masked])**2)**0.5\\n vec_temp.close()\\n return distance, min_dist_cl\",\n \"def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\\n res = []\\n for n_clusters in n_clusters_considered:\\n res.append([])\\n for _ in range(n_repeats):\\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\\n print(X.val.shape)\\n print(X_restricted.val.shape)\\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\\n res[-1].append(evaluator_X.weighted_average) \\n return res\",\n \"def getCluster(self, eps = None, minPts = None):\\n #D = getDistanceMatrix()\\n #print(\\\"Distance matrix completed, clustering in process\\\")\\n clusters = DBSCAN(metric=Categorization.cosin_sim_pairs).fit_predict(np.arange(186696).reshape(-1, 1))\\n print(\\\"Clustering completed, writing pickle file\\\")\\n self.writeFile(clusters, \\\"clusters.pickle\\\")\\n return clusters\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def create_cluster(df,validate, test, X, k, name):\\n \\n scaler = StandardScaler(copy=True).fit(df[X])\\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\\n kmeans = KMeans(n_clusters = k, random_state = 42)\\n kmeans.fit(X_scaled)\\n kmeans.predict(X_scaled)\\n df[name] = kmeans.predict(X_scaled)\\n df[name] = 'cluster_' + df[name].astype(str)\\n \\n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\\n validate[name] = kmeans.predict(v_scaled)\\n validate[name] = 'cluster_' + validate[name].astype(str)\\n \\n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\\n test[name] = kmeans.predict(t_scaled)\\n test[name] = 'cluster_' + test[name].astype(str)\\n \\n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\\n return df, X_scaled, scaler, kmeans, centroids\",\n \"def cluster_dist(self):\\n clusters = self.all_clusters()\\n lengths = [len(cluster) for cluster in clusters]\\n d = Dist(lengths)\\n d.plot_ccdf(loglog)\\n show()\",\n \"def cluster_center_update_dataset(spn, dataset):\\n\\n if isinstance(spn, Categorical):\\n\\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, IdentityNumericLeaf):\\n\\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, Sum):\\n cc = spn.cluster_centers\\n\\n node_idx = 0\\n\\n min_dist = np.inf\\n min_idx = -1\\n for n in spn.children:\\n # distance calculation between the dataset and the different clusters\\n # (there exist a much faster version on scipy)\\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\\n #\\n proj = projection(dataset, n.scope)\\n dist = distance.euclidean(cc[node_idx], proj)\\n if dist < min_dist:\\n min_dist = dist\\n min_idx = node_idx\\n\\n node_idx += 1\\n assert min_idx > -1\\n assert min_idx < len(spn.children)\\n adapt_weights(spn, min_idx)\\n cluster_center_update_dataset(spn.children[min_idx], dataset)\\n elif isinstance(spn, Product):\\n\\n for n in spn.children:\\n cluster_center_update_dataset(n, dataset)\\n else:\\n raise Exception(\\\"Invalid node type \\\" + str(type(spn)))\\n spn.cardinality += 1\",\n \"def cluster_data(attrs):\\n if projection_exists(attrs):\\n df = load_df()\\n X = load_X()\\n else:\\n X, df = get_projection(attrs)\\n\\n # Execute clustering\\n model = cluster_algorithms[attrs['algorithm']](X, attrs)\\n labels = model.labels_ \\\\\\n if hasattr(model, 'labels_') \\\\\\n else model.predict(X)\\n\\n # Save clusters for tfidf and similar\\n df['clx_cluster'] = labels\\n\\n save_df(df)\\n save_cluster_model(model)\\n return scatterplot(X, labels, df['clx_id'])\",\n \"def generate_queries(DIMS,t,data):\\n #Start With clusters\\n x = np.linspace(0,1,6)\\n a = [x.tolist()]*DIMS\\n #Define cluster centers and covariance matrix\\n cluster_centers = list(itertools.product(*a))\\n cov = np.identity(DIMS)*0.2\\n logger.debug(\\\"Generating queries at %d cluster centers\\\" % len(cluster_centers))\\n query_centers = []\\n #Generate queries over cluster centers\\n for c in cluster_centers:\\n queries = np.random.multivariate_normal(np.array(c), cov, size=50)\\n query_centers.append(queries)\\n query_centers = np.array(query_centers).reshape(-1,DIMS)\\n \\n ranges = np.random.uniform(low=0.03**(1/DIMS), high=0.15**(1/DIMS), size=(query_centers.shape[0], 1))\\n ranges = np.ones((query_centers.shape[0], DIMS))*ranges\\n assert(ranges.shape[0]==query_centers.shape[0])\\n queries = []\\n i=0\\n logger.debug(\\\"Query Generation\\\")\\n for q,r in zip(query_centers,ranges):\\n b = generate_boolean_vector(data,q,r,DIMS)\\n if t=='density':\\n qt = q.tolist()\\n qt += r.tolist()\\n qt.append(execute_query_dens(b,data))\\n queries.append(qt)\\n elif t=='aggr':\\n qt = q.tolist()\\n qt += r.tolist()\\n qt.append(execute_query_aggr(b,data))\\n queries.append(qt)\\n i+=1\\n logger.debug(\\\"Generated {0} queries\\\".format(len(queries)))\\n return queries\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def fiedler_clustering(self, num_clusters):\\n\\n clusters = MiniBatchKMeans(n_clusters=num_clusters).fit_predict(self.graph)\\n\\n return clusters\",\n \"def Datacenters(self):\\n if not self._datacenters:\\n dcs = self._get_objects(vim.Datacenter)\\n for dc in dcs:\\n self._datacenters[dc.name] = dc\\n return self._datacenters\",\n \"def extract_clusters (points, labels):\\n assert_points_2d (points)\\n assert_labels (labels)\\n\\n id_label_pairs = list (enumerate (set (labels.flatten ())))\\n labels_map = dict ([(v, i) for (i, v) in id_label_pairs])\\n \\n # Count how many points belong to each cluster\\n counts = [0] * len (labels_map)\\n for l in labels.flatten ():\\n counts[labels_map[l]] += 1\\n \\n # Allocate space for each cluster\\n clusters = [np.zeros ((k, 3)) for k in counts]\\n \\n # Separate the points by cluster\\n counts = [0] * len (labels_map)\\n for (x, l) in zip (points, labels.flatten ()):\\n l_id = labels_map[l]\\n k = counts[l_id]\\n clusters[l_id][k, :] = x\\n counts[l_id] += 1\\n \\n # Generate cluster labels\\n cluster_labels = [None] * len (labels_map)\\n for (l, i) in labels_map.items ():\\n cluster_labels[i] = l\\n \\n return (clusters, cluster_labels)\",\n \"def createInputPointCloud(side_size:int, center_x:int, center_y:int, nb_pts:int):\\n in_pts = np.zeros(shape=(nb_pts,2), dtype=np.float32)\\n side_nb_pts = nb_pts / 4\\n ds = side_size / side_nb_pts\\n for i in range(nb_pts):\\n if i < side_nb_pts:\\n in_pts[i][0] = center_x + i * ds - side_size * 0.5\\n in_pts[i][1] = center_y + side_size / 2\\n elif i < 2 * side_nb_pts:\\n in_pts[i][0] = center_x + side_size / 2\\n in_pts[i][1] = center_y + (i - 1*side_nb_pts) * ds - side_size * 0.5\\n elif i < 3 * side_nb_pts:\\n in_pts[i][0] = center_x + (i - 2*side_nb_pts) * ds - side_size * 0.5\\n in_pts[i][1] = center_y - side_size / 2\\n else:\\n in_pts[i][0] = center_x - side_size / 2\\n in_pts[i][1] = center_y + (i - 3*side_nb_pts) * ds - side_size * 0.5\\n return in_pts\",\n \"def dictionary(descriptors, n_clusters):\\n # TODO\\n print(descriptors.shape)\\n dummy=MiniBatchKMeans(n_clusters=n_clusters, batch_size=3000, random_state=9).fit(descriptors)\\n clusters=dummy.cluster_centers_\\n return clusters\",\n \"def calculate_distances(data_point, centroids):\\n distances = []\\n for centroid_index, centroid_value in enumerate(centroids):\\n distances.append(distance(data_point, centroid_value))\\n return distances\",\n \"def point_dists(base_sets,new_sets):\\n res = np.zeros(new_sets.shape[0])\\n for ix in range(len(res)):\\n diffs = base_sets[:]-new_sets[ix]\\n dists = np.sum(np.square(diffs),axis=-1)\\n maxd = np.max(dists,axis=-1) \\n res[ix] = np.min(maxd)\\n return res\",\n \"def calc_final_clusters(sp_initial, km_initial):\\r\\n sp_final = kc.kmeans(T.tolist(), sp_initial, k, n, k, MAX_ITER)\\r\\n km_final = kc.kmeans(data.tolist(), km_initial, k, n, d, MAX_ITER)\\r\\n if km_final is None or sp_final is None:\\r\\n exit(1)\\r\\n spectral_clusters = np.array(sp_final)\\r\\n kmeans_clusters = np.array(km_final)\\r\\n\\r\\n return spectral_clusters, kmeans_clusters\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75692487","0.6472027","0.6142992","0.61193955","0.61097693","0.6057844","0.6014714","0.5996427","0.59905845","0.5968957","0.5963011","0.5947673","0.5943788","0.5909058","0.5908519","0.5902958","0.5898489","0.5893198","0.58916074","0.58719695","0.5860178","0.58107644","0.5805139","0.57562363","0.5730351","0.57294756","0.5717863","0.57104343","0.5698351","0.56826884","0.56712353","0.566387","0.5646856","0.56457543","0.56249714","0.5624722","0.56043273","0.55954367","0.55904585","0.55815357","0.5558281","0.55541986","0.55541986","0.55428046","0.55359733","0.55316573","0.5525696","0.5508293","0.5499269","0.54973","0.54582477","0.54541063","0.54505247","0.5444572","0.54414594","0.5438354","0.5435408","0.54330295","0.54199064","0.54180706","0.5403561","0.5402613","0.5397696","0.5395738","0.5394558","0.53926945","0.53877306","0.53839767","0.5381197","0.53763175","0.53751","0.53727967","0.53411496","0.53396904","0.5336874","0.53266704","0.53262025","0.5320125","0.5319879","0.531826","0.5312697","0.5310484","0.53086704","0.5303336","0.5303242","0.52984744","0.5297826","0.5293786","0.5291704","0.5280158","0.52762747","0.5275717","0.52750635","0.52676785","0.5255942","0.52551997","0.52529734","0.5251785","0.524009","0.52398986"],"string":"[\n \"0.75692487\",\n \"0.6472027\",\n \"0.6142992\",\n \"0.61193955\",\n \"0.61097693\",\n \"0.6057844\",\n \"0.6014714\",\n \"0.5996427\",\n \"0.59905845\",\n \"0.5968957\",\n \"0.5963011\",\n \"0.5947673\",\n \"0.5943788\",\n \"0.5909058\",\n \"0.5908519\",\n \"0.5902958\",\n \"0.5898489\",\n \"0.5893198\",\n \"0.58916074\",\n \"0.58719695\",\n \"0.5860178\",\n \"0.58107644\",\n \"0.5805139\",\n \"0.57562363\",\n \"0.5730351\",\n \"0.57294756\",\n \"0.5717863\",\n \"0.57104343\",\n \"0.5698351\",\n \"0.56826884\",\n \"0.56712353\",\n \"0.566387\",\n \"0.5646856\",\n \"0.56457543\",\n \"0.56249714\",\n \"0.5624722\",\n \"0.56043273\",\n \"0.55954367\",\n \"0.55904585\",\n \"0.55815357\",\n \"0.5558281\",\n \"0.55541986\",\n \"0.55541986\",\n \"0.55428046\",\n \"0.55359733\",\n \"0.55316573\",\n \"0.5525696\",\n \"0.5508293\",\n \"0.5499269\",\n \"0.54973\",\n \"0.54582477\",\n \"0.54541063\",\n \"0.54505247\",\n \"0.5444572\",\n \"0.54414594\",\n \"0.5438354\",\n \"0.5435408\",\n \"0.54330295\",\n \"0.54199064\",\n \"0.54180706\",\n \"0.5403561\",\n \"0.5402613\",\n \"0.5397696\",\n \"0.5395738\",\n \"0.5394558\",\n \"0.53926945\",\n \"0.53877306\",\n \"0.53839767\",\n \"0.5381197\",\n \"0.53763175\",\n \"0.53751\",\n \"0.53727967\",\n \"0.53411496\",\n \"0.53396904\",\n \"0.5336874\",\n \"0.53266704\",\n \"0.53262025\",\n \"0.5320125\",\n \"0.5319879\",\n \"0.531826\",\n \"0.5312697\",\n \"0.5310484\",\n \"0.53086704\",\n \"0.5303336\",\n \"0.5303242\",\n \"0.52984744\",\n \"0.5297826\",\n \"0.5293786\",\n \"0.5291704\",\n \"0.5280158\",\n \"0.52762747\",\n \"0.5275717\",\n \"0.52750635\",\n \"0.52676785\",\n \"0.5255942\",\n \"0.52551997\",\n \"0.52529734\",\n \"0.5251785\",\n \"0.524009\",\n \"0.52398986\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6139342"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9483,"cells":{"query":{"kind":"string","value":"Create a deltaseparated dataset. For each of the centers draw size number of points. No two points may be farther than delta away form each other. Thus, to generate each point, choosea random direction and random distance from the center (of up to 0.5 delta)."},"document":{"kind":"string","value":"def _create_constrained_dataset(centers, delta, size):\n dataset = []\n count = 0\n for i, c in enumerate(centers):\n for j in range(size):\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\n direction = x / np.linalg.norm(x)\n magnitude = np.random.uniform(0.0, 0.5 * delta)\n # magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED\n dataset.append((c + magnitude * direction, i, count))\n count += 1\n return dataset"},"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 generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\n self.d = d\n\n # 95% of data lies in a 2*sigma ball around the mean.\n # For unit variance normal, the 2*sigma ball mean the centers\n # should be at distance of 4 in the d dimensional space.\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\n cov = np.eye(d)\n\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\n # print(dist_mean)\n # cov = np.eye(d)\n\n frac = int(1 / pos_fraction)\n\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\n\n self.X = np.vstack((cluster1, cluster2))\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\n\n # Make blobs\n # if True:\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)","def prepare_data_for_d(self):\n\n center_nodes = []\n neighbor_nodes = []\n labels = []\n for i in self.root_nodes:\n if np.random.rand() < config.update_ratio:\n # self.graph[i] = [neighbors of i]\n pos = self.graph[i]\n neg, _ = self.sample(i, self.trees[i], len(pos), for_d=True)\n # print(\"tree_i_d: \", self.trees[i])\n # print(\"neg_samples: \", neg)\n # print(\"neg is: \", neg)\n if len(pos) != 0 and neg is not None:\n # positive samples\n center_nodes.extend([i] * len(pos))\n neighbor_nodes.extend(pos)\n labels.extend([1] * len(pos))\n\n # negative samples\n center_nodes.extend([i] * len(pos))\n neighbor_nodes.extend(neg)\n labels.extend([0] * len(neg))\n # print(\"cen: \", center_nodes)\n return center_nodes, neighbor_nodes, labels","def generateData(numPoints,x,y):\n\tfor i in range(0,numPoints):\n\t\tif (i % 2 == 0):\n\t\t\tx.append(random.normalvariate(25, 15))\n\t\t\ty.append(random.normalvariate(25, 15))\n\t\t\t \n\t\t\t\n\t\telse:\n\t\t\tx.append(random.normalvariate(75, 15))\n\t\t\ty.append(random.normalvariate(75, 15))","def random_verts2D_deviation(vertices, delta_verts2d_dev_range=[-0.01, 0.01]):\n batch_size = vertices.shape[0]\n num_verts = vertices.shape[1]\n device = vertices.device\n\n noisy_vertices = vertices.clone()\n\n l, h = delta_verts2d_dev_range\n delta_verts2d_dev = (h - l) * torch.rand(batch_size, num_verts, 2, device=device) + l\n noisy_vertices[:, :, :2] = noisy_vertices[:, :, :2] + delta_verts2d_dev\n\n return noisy_vertices","def generate_samples(delta=1, n=32):\n X = np.zeros((n, NROW * NCOL))\n Y = np.zeros((n, NROW * NCOL))\n for i in range(n):\n x, y = generate_sample(delta)\n X[i, :] = x\n Y[i, :] = y\n return X, Y","def random_projection_split(data, indices, rng_state):\n dim = data.shape[1]\n\n # Select two random points, set the hyperplane between them\n left_index = tau_rand_int(rng_state) % indices.shape[0]\n right_index = tau_rand_int(rng_state) % indices.shape[0]\n right_index += left_index == right_index\n right_index = right_index % indices.shape[0]\n left = indices[left_index]\n right = indices[right_index]\n\n # Compute the normal vector to the hyperplane (the vector between\n # the two points) and the offset from the origin\n hyperplane_offset = 0.0\n hyperplane_vector = np.empty(dim, dtype=np.float32)\n\n for d in range(dim):\n hyperplane_vector[d] = data[left, d] - data[right, d]\n hyperplane_offset -= hyperplane_vector[d] * (\n data[left, d] + data[right, d]) / 2.0\n\n # For each point compute the margin (project into normal vector, add offset)\n # If we are on lower side of the hyperplane put in one pile, otherwise\n # put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n n_left = 0\n n_right = 0\n side = np.empty(indices.shape[0], np.int8)\n for i in range(indices.shape[0]):\n margin = hyperplane_offset\n for d in range(dim):\n margin += hyperplane_vector[d] * data[indices[i], d]\n\n if margin == 0:\n side[i] = tau_rand_int(rng_state) % 2\n if side[i] == 0:\n n_left += 1\n else:\n n_right += 1\n elif margin > 0:\n side[i] = 0\n n_left += 1\n else:\n side[i] = 1\n n_right += 1\n\n # Now that we have the counts allocate arrays\n indices_left = np.empty(n_left, dtype=np.int64)\n indices_right = np.empty(n_right, dtype=np.int64)\n\n # Populate the arrays with indices according to which side they fell on\n n_left = 0\n n_right = 0\n for i in range(side.shape[0]):\n if side[i] == 0:\n indices_left[n_left] = indices[i]\n n_left += 1\n else:\n indices_right[n_right] = indices[i]\n n_right += 1\n\n return indices_left, indices_right","def ddds(cloud, sample_size, presample=None, processes=10):\n\n #--------------------------------------------------------------------------\n\n ### Prep\n\n # Handle small point clouds\n if cloud.shape[0] <= sample_size:\n warn(\"(code 1) Point cloud is already <= desired sample size. \" +\n \"No subsampling is performed.\")\n return cloud\n\n\n #--------------------------------------------------------------------------\n\n ### Compute per-landmark local densities\n\n # Subsample randomly (for speed/memory efficiency)\n if presample is not None:\n cloud_presubs = random_subsample(cloud, presample)\n else:\n cloud_presubs = np.copy(cloud)\n\n # Compute distance of each subsampled point to the closest other point\n # Note: `k=2` is necessary since `k=1` is the point itself.\n tree = cKDTree(cloud)\n NN_dists = tree.query(cloud_presubs, k=2, n_jobs=processes)[0][:,1]\n\n # Get the size of the local neighborhood\n # which is `alpha * median(smallest_distances)`,\n # where a good value for alpha is 5 according to SPADE\n alpha = 5\n NN_size = alpha * np.median(NN_dists)\n\n # Get the local density (LD) of each landmark\n # ...which is the number of other landmarks in its local neighborhood\n LDs = tree.query_ball_point(cloud, NN_size, n_jobs=processes) # Get indices\n LDs = np.vectorize(len)(LDs) # Count\n\n # Define the target density (TD)\n # Note: Good values according to SPADE: the 3rd or 5th percentile of LDs\n # Note: This effectively defines how strongly the data will be subsampled\n TD_percentile = 3\n TD = np.percentile(LDs, TD_percentile)\n\n\n #--------------------------------------------------------------------------\n\n ### Perform density-dependent subsampling\n\n # Create p(keep_lm) probability vector\n # Note: For each point i, the probability of keeping it is\n # { 1 if LD_i < TD\n # { TD / LD_i otherwise\n p_keep = TD / LDs\n p_keep[LDs<TD] = 1\n\n # Randomly decide if a landmark should be kept according to p(keep_lm)\n rand = np.random.uniform(size=cloud.shape[0])\n keep = p_keep >= rand\n\n # Index the lms to be kept\n cloud_ddds = cloud[keep,:]\n\n\n #--------------------------------------------------------------------------\n\n ### Further random downsampling\n\n # Note: This ensures that the downsampled cloud does not grow with the\n # input data and instead is of the specified sample_size or smaller.\n\n if cloud_ddds.shape[0] > sample_size:\n cloud_ddds = random_subsample(cloud_ddds, sample_size)\n\n #--------------------------------------------------------------------------\n\n ### Return result\n return cloud_ddds","def crescent_data(num_data=200, seed=default_seed):\r\n np.random.seed(seed=seed)\r\n sqrt2 = np.sqrt(2)\r\n # Rotation matrix\r\n R = np.array([[sqrt2 / 2, -sqrt2 / 2], [sqrt2 / 2, sqrt2 / 2]])\r\n # Scaling matrices\r\n scales = []\r\n scales.append(np.array([[3, 0], [0, 1]]))\r\n scales.append(np.array([[3, 0], [0, 1]]))\r\n scales.append([[1, 0], [0, 3]])\r\n scales.append([[1, 0], [0, 3]])\r\n means = []\r\n means.append(np.array([4, 4]))\r\n means.append(np.array([0, 4]))\r\n means.append(np.array([-4, -4]))\r\n means.append(np.array([0, -4]))\r\n\r\n Xparts = []\r\n num_data_part = []\r\n num_data_total = 0\r\n for i in range(0, 4):\r\n num_data_part.append(round(((i + 1) * num_data) / 4.))\r\n num_data_part[i] -= num_data_total\r\n part = np.random.normal(size=(num_data_part[i], 2))\r\n part = np.dot(np.dot(part, scales[i]), R) + means[i]\r\n Xparts.append(part)\r\n num_data_total += num_data_part[i]\r\n X = np.vstack((Xparts[0], Xparts[1], Xparts[2], Xparts[3]))\r\n\r\n Y = np.vstack((np.ones((num_data_part[0] + num_data_part[1], 1)), -np.ones((num_data_part[2] + num_data_part[3], 1))))\r\n return {'X':X, 'Y':Y, 'info': \"Two separate classes of data formed approximately in the shape of two crescents.\"}","def generatePoints(centre: Point, radius: float, numPoints: int, jitterRatio: float = 0) -> List[Point]:\n def jitter() -> float:\n diamiter = radius * math.pi * 2\n jitterSize = jitterRatio * diamiter / numPoints\n return random.random() * 2 * jitterSize - jitterSize\n\n points: List[Point] = []\n angle_segment = math.pi * 2 / numPoints\n angle = 0\n\n while angle < math.pi * 2:\n point = (centre[0] + radius * math.cos(angle) + jitter(),\n centre[1] + radius * math.sin(angle) + jitter())\n points.append(point)\n angle += angle_segment\n\n return points","def test_with_predefined_dist(self, seed):\n dim = Dimension(\"yolo\", dists.norm, 0.9)\n samples = dim.sample(seed=seed)\n assert len(samples) == 1\n assert dists.norm.rvs(0.9) == samples[0]","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def generate_triangle(seed, num_points=200):\n points = {\n 0: 750,\n 750: 0,\n 1500: 751\n }\n random.seed(seed)\n while len(points) < num_points:\n y_coord = (random.randrange(500) or 1) + 200\n x_coord = random.randrange(round(y_coord*4/3)) + round((500 - y_coord)*(3/4)) + 400\n if (not points.get(x_coord)) and (x_coord != 750):\n points[x_coord] = y_coord\n\n os.makedirs(os.path.join(DATA_DIR, seed), exist_ok=True)\n filepath = os.path.join(DATA_DIR, '{}/triangle.node'.format(seed))\n\n # creates the input nodes used by triangle to create delauney graph\n with open(filepath, 'w') as node_file:\n header = \"{} 2 0 0\\n\".format(len(points))\n node_file.write(header)\n i = 1\n for x_coord, y_coord in points.items():\n node_file.write(\" {} {} {}\\n\".format(i, x_coord, y_coord))\n i += 1\n node_file.close()\n\n call(['triangle', '-e', filepath])","def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\n\n # generate clusters of blobs\n generated_points_x, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_x,\n cluster_std=std,\n n_features=1,\n )\n\n generated_points_y, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_y,\n cluster_std=std,\n n_features=1,\n )\n\n # remove decimals\n generated_points_x = generated_points_x.astype(\"int\")\n generated_points_y = generated_points_y.astype(\"int\")\n\n ind_delete = np.logical_or.reduce(\n (\n generated_points_x < 0,\n generated_points_y < 0,\n generated_points_x > xsize - 1,\n generated_points_y > ysize - 1,\n ),\n )\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n\n return generated_points_x, generated_points_y","def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\n rand.seed(seed)\n cluster_boundaries = np.cumsum(cluster_sizes)\n print(\"#seed:\", seed)\n print(\"#deletion factor:\", del_factor)\n print(\"#insertion factor:\", ins_factor)\n optimal_costs = np.array([0])\n for c in range(0, len(cluster_sizes)-1):\n n_c = cluster_sizes[c+1]\n offset_c = cluster_boundaries[c]\n edges_c = generate_edges(n_c, offset_c)\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\n print(\"#optimal costs:\", optimal_costs)","def generate_curves(self, seed=None):\n num_context = tf.random_uniform(\n shape=[], minval=self._min_num_context, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\n\n # If we are testing we want to have more targets and have them evenly\n # distributed in order to plot the function.\n if self._testing:\n num_target = self._num_pts_per_inst #self._x_data.get_shape().as_list()[0]\n num_total_points = num_target\n # During training the number of target points and their x-positions are\n # selected at random\n else:\n num_target = tf.random_uniform(shape=(), minval=0, \n maxval=self._max_num_context - num_context,\n dtype=tf.int32, seed=seed)\n num_total_points = num_context + num_target\n\n # idx for x vals in target\n idxs = []\n # which instance to get y data from\n insts = []\n for i in range(self._batch_size):\n idxs.append( tf.random_shuffle(tf.range(self._num_pts_per_inst), seed=seed) )\n insts.append( tf.random_uniform(shape=[], minval=0, maxval=self._num_inst-1, dtype=tf.int32, seed=seed) )\n \n idxs = tf.stack(idxs)\n insts = tf.stack(insts)\n \n # batchsize x numtotalpoints x size (xsize or ysize)\n x_values = tf.stack([tf.expand_dims(tf.gather(self._x_uniq, idxs[tf.cast(i,tf.int32)][:tf.cast(num_total_points,tf.int32)]), axis=-1) for i in range(self._batch_size)])\n y_values = tf.stack([tf.expand_dims(tf.gather(self._y_data[insts[i]*self._num_pts_per_inst:(insts[i]+1)*self._num_pts_per_inst], idxs[i][:num_total_points]), axis=-1) for i in range(self._batch_size)])\n \n \n \n if self._testing:\n # Select the targets\n target_x = x_values\n target_y = y_values\n\n # Select the observations\n idx_ctxt = tf.random_shuffle(tf.range(num_target), seed=seed)\n context_x = tf.gather(x_values, idx_ctxt[:num_context], axis=1)\n context_y = tf.gather(y_values, idx_ctxt[:num_context], axis=1)\n\n else:\n # Select the targets which will consist of the context points as well as\n # some new target points\n target_x = x_values[:, :num_target + num_context, :]\n target_y = y_values[:, :num_target + num_context, :]\n\n # Select the observations\n context_x = x_values[:, :num_context, :]\n context_y = y_values[:, :num_context, :]\n \n context_x = tf.squeeze(context_x,-1)\n target_x = tf.squeeze(target_x,-1)\n\n context_y = tf.squeeze(context_y,-1)\n target_y= tf.squeeze(target_y,-1)\n\n query = ((context_x, context_y), target_x)\n\n return NPRegressionDescription(\n query=query,\n target_y=target_y,\n num_total_points=tf.shape(target_x)[1],\n num_context_points=num_context)","def randomize_spaced_out_points(space, separation, n_points):\n #obj = poisson_disk.pds(space[0], space[1], space[2], separation, n_points)\n obj = naive_spaced_randomizer.naive_spaced_randomizer(space[0], space[1], space[2], separation, n_points)\n return obj.randomize_spaced_points()","def make_datagens(data_points):\n data_gen_args = dict(\n rotation_range=10.,\n width_shift_range=0.1,\n height_shift_range=0.1,\n zoom_range=0.1,\n )\n\n x_datagen = keras.preprocessing.image.ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization=True,\n **data_gen_args,\n )\n\n y_datagen = keras.preprocessing.image.ImageDataGenerator(\n featurewise_center=False,\n featurewise_std_normalization=False,\n **data_gen_args,\n )\n\n x_datagen.fit(utils.list_of_images_to_4d_array([dp.x for dp in data_points]))\n y_datagen.fit(utils.list_of_images_to_4d_array([dp.y for dp in data_points]))\n\n return [x_datagen, y_datagen]","def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\n np.random.seed(12345)\n a, b, c = nvect / np.linalg.norm(nvect)\n x, y = np.random.rand(npts), np.random.rand(npts)\n z = (dparam - a * x - b * y) / c\n if eps > 0:\n z += np.random.normal(loc=0., scale=eps, size=npts)\n return np.column_stack((x, y, z))","def random_linearly_separable_data(num_points, bounds):\n\n points = random_plane_points(num_points, bounds)\n weights = random_hyperplane(bounds)\n labels = np.sign(np.dot(np.column_stack([np.ones((num_points, 1)), \n points]), weights))\n return (points, labels, weights)","def create_data(self, N, d):\n X_neg = np.random.randn(np.floor(N/2.0), d) + 2*np.ones((1, d))\n X_pos = np.random.randn(np.ceil(N/2.0), d) - 2*np.ones((1, d))\n X = np.vstack((X_neg, X_pos))\n\n Y_neg = np.zeros((np.floor(N/2.0), 1))\n Y_pos = np.ones((np.ceil(N/2.0), 1))\n Y = np.vstack((Y_neg, Y_pos))\n\n return Data(X, Y)","def generate_curves(self, seed=None):\n num_context = tf.random_uniform(\n shape=[], minval=3, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\n\n # If we are testing we want to have more targets and have them evenly\n # distributed in order to plot the function.\n if self._testing:\n num_target = self._x_data.get_shape().as_list()[0]\n num_total_points = num_target\n # During training the number of target points and their x-positions are\n # selected at random\n else:\n num_target = tf.random_uniform(shape=(), minval=0, \n maxval=self._max_num_context - num_context,\n dtype=tf.int32, seed=seed)\n num_total_points = num_context + num_target\n\n # idx for x vals in target\n idxs = []\n # which instance to get y data from\n insts = []\n for i in range(self._batch_size):\n idxs.append( tf.random_shuffle(tf.range(self._num_pts_per_inst), seed=seed) )\n insts.append( tf.random_uniform(shape=[], minval=0, maxval=self._num_inst-1, dtype=tf.int32, seed=seed) )\n \n idxs = tf.stack(idxs)\n insts = tf.stack(insts)\n \n # batchsize x numtotalpoints x size (xsize or ysize)\n x_values = tf.stack([tf.expand_dims(tf.gather(self._x_uniq, idxs[tf.cast(i,tf.int32)][:tf.cast(num_total_points,tf.int32)]), axis=-1) for i in range(self._batch_size)])\n y_values = tf.stack([tf.expand_dims(tf.gather(self._y_data[insts[i]*self._num_pts_per_inst:(insts[i]+1)*self._num_pts_per_inst], idxs[i][:num_total_points]), axis=-1) for i in range(self._batch_size)])\n \n \n \n if self._testing:\n # Select the targets\n target_x = x_values\n target_y = y_values\n\n # Select the observations\n idx_ctxt = tf.random_shuffle(tf.range(num_target), seed=seed)\n context_x = tf.gather(x_values, idx_ctxt[:num_context], axis=1)\n context_y = tf.gather(y_values, idx_ctxt[:num_context], axis=1)\n\n else:\n # Select the targets which will consist of the context points as well as\n # some new target points\n target_x = x_values[:, :num_target + num_context, :]\n target_y = y_values[:, :num_target + num_context, :]\n\n # Select the observations\n context_x = x_values[:, :num_context, :]\n context_y = y_values[:, :num_context, :]\n \n context_x = tf.squeeze(context_x,-1)\n target_x = tf.squeeze(target_x,-1)\n\n query = ((context_x, context_y), target_x)\n\n return NPRegressionDescription(\n query=query,\n target_y=target_y,\n num_total_points=tf.shape(target_x)[1],\n num_context_points=num_context)","def generate_data(nb_samples):\n inputs = torch.empty(nb_samples, 2).uniform_(0, 1)\n center = Tensor([0.5, 0.5]).view(1, -1)\n distances = torch.norm((inputs - center).abs(), 2, 1)\n labels = (distances < 1 / math.sqrt(2 * math.pi)).type(LongTensor)\n return inputs.t(), labels","def random():\n # Define lattice spacing as a multiple of the particle radius\n # using the formula a = 4 r/sqrt(3). Systems which are ordered\n # are probably mostly filled, so use a distribution which goes from\n # zero to one, but leaving 90% of them within 80% of the\n # maximum bcc packing. Lattice distortion values are empirically\n # useful between 0.01 and 0.7. Use an exponential distribution\n # in this range 'cuz its easy.\n radius = 10**np.random.uniform(1.3, 4)\n d_factor = 10**np.random.uniform(-2, -0.7) # sigma_d in 0.01-0.7\n dnn_fraction = np.random.beta(a=10, b=1)\n dnn = radius*4/np.sqrt(3)/dnn_fraction\n pars = dict(\n #sld=1, sld_solvent=0, scale=1, background=1e-32,\n dnn=dnn,\n d_factor=d_factor,\n radius=radius,\n )\n return pars","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def _random_points_3d(self, number_of_seeds, min_z, max_z):\n # Sanity check. We can't get more seeds than what's available in the bounds\n assert number_of_seeds <= self.cell_count\n\n found = {}\n while len(found) < number_of_seeds:\n pt = Point2D(random.randint(self._lower_left.x, self._upper_right.x),\n random.randint(self._lower_left.y, self._upper_right.y))\n if pt not in found: # make sure unique\n found[pt] = random.randint(min_z, max_z)\n return [Point3D(pt.x, pt.y, z) for pt, z in found.items()]","def _getDistribution(\n self, targetPoints, minDudes, maxDudes, groupCount, maxLevel):\n\n maxIterations = 10+maxDudes*2\n\n def _getTotals(groups):\n totalPoints = 0\n totalDudes = 0\n for group in groups:\n for entry in group:\n dudes = entry[1]\n totalPoints += entry[0]*dudes\n totalDudes += dudes\n return totalPoints, totalDudes\n\n groups = []\n for g in range(groupCount):\n groups.append([])\n\n types = [1]\n if maxLevel > 1:\n types.append(2)\n if maxLevel > 2:\n types.append(3)\n if maxLevel > 3:\n types.append(4)\n\n for iteration in range(maxIterations):\n # see how much we're off our target by\n totalPoints, totalDudes = _getTotals(groups)\n diff = targetPoints - totalPoints\n dudesDiff = maxDudes - totalDudes\n # add an entry if one will fit\n value = types[random.randrange(len(types))]\n group = groups[random.randrange(len(groups))]\n if len(group) == 0:\n maxCount = random.randint(1, 6)\n else:\n maxCount = 2*random.randint(1, 3)\n maxCount = min(maxCount, dudesDiff)\n count = min(maxCount, diff/value)\n if count > 0:\n group.append((value, count))\n totalPoints += value*count\n totalDudes += count\n diff = targetPoints - totalPoints\n\n totalPoints, totalDudes = _getTotals(groups)\n full = (totalPoints >= targetPoints)\n\n if full:\n # every so often, delete a random entry just to\n # shake up our distribution\n if random.random() < 0.2 and iteration != maxIterations-1:\n entryCount = 0\n for group in groups:\n for entry in group:\n entryCount += 1\n if entryCount > 1:\n delEntry = random.randrange(entryCount)\n entryCount = 0\n for group in groups:\n for entry in group:\n if entryCount == delEntry:\n group.remove(entry)\n break\n entryCount += 1\n\n # if we don't have enough dudes, kill the group with\n # the biggest point value\n elif totalDudes < minDudes and iteration != maxIterations-1:\n biggestValue = 9999\n biggestEntry = None\n for group in groups:\n for entry in group:\n if entry[0] > biggestValue or biggestEntry is None:\n biggestValue = entry[0]\n biggestEntry = entry\n biggestEntryGroup = group\n if biggestEntry is not None:\n biggestEntryGroup.remove(biggestEntry)\n\n # if we've got too many dudes, kill the group with the\n # smallest point value\n elif totalDudes > maxDudes and iteration != maxIterations-1:\n smallestValue = 9999\n smallestEntry = None\n for group in groups:\n for entry in group:\n if entry[0] < smallestValue or smallestEntry is None:\n smallestValue = entry[0]\n smallestEntry = entry\n smallestEntryGroup = group\n smallestEntryGroup.remove(smallestEntry)\n\n # close enough.. we're done.\n else:\n if diff == 0:\n break\n\n return groups","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def create_data(self):\n\n print (f'Using {self.n_s} simulations for the training data to estimate cov')\n print (f'Using {self.n_p} simulations for the upper/lower training data')\n print (f'Number of splits, to increase number simulations: {self.n_train}')\n print (f'Adding noise to the derivative: {np.invert(self.noiseless_deriv)}')\n\n # Number of upper and lower simulations\n n_p = int(self.n_s * self.derivative_fraction)\n\n # set a seed to surpress the sample variance (EVEN FOR CENTRAL SIMULATIONS)\n seed = np.random.randint(1e6) \n # We should double-check to see if the sample variance if being surpressed\n\n # Perturb lower \n np.random.seed(seed)\n t_m = self.generate_data(np.array([self.theta_fid for i in \n range(self.n_train * self.n_p)])\n ,train = -self.delta_theta, flatten = self.flatten\n ,noiseless_deriv = self.noiseless_deriv) \n # Perturb higher \n np.random.seed(seed)\n t_p = self.generate_data(np.array([theta_fid for i in \n range(self.n_train * self.n_p)])\n ,train = self.delta_theta, flatten = self.flatten\n , noiseless_deriv = self.noiseless_deriv)\n\n # Central\n np.random.seed(seed)\n t = self.generate_data(np.array([self.theta_fid for i in \n range(self.n_train * self.n_s)])\n ,train = None, flatten = self.flatten)\n\n\n # derivative data\n t_d = (t_p - t_m) / (2. * self.delta_theta)\n\n # Save in a dict that the network takes\n data = {\"data\": t, \"data_d\": t_d}\n # for plotting purposes we save the upper/lower separately as well\n data[\"x_m\"], data[\"x_p\"] = t_m, t_p \n\n\n # Repeat the same story to generate test data\n print ('\\n')\n print (f'Using {self.n_s} simulations for the test data to estimate cov')\n print (f'Using {self.n_p_val} simulations for the upper/lower test data')\n print (f'Number of splits, to increase number simulations: {self.n_train_val}')\n print (f'Adding noise to the derivative: {np.invert(self.noiseless_deriv)}')\n print ('\\n')\n\n seed = np.random.randint(1e6)\n # Perturb lower \n np.random.seed(seed)\n tt_m = self.generate_data(np.array([self.theta_fid for i in \n range(self.n_train * self.n_p)])\n , train = -self.delta_theta, flatten = self.flatten\n , noiseless_deriv = self.noiseless_deriv)\n # Perturb higher \n np.random.seed(seed)\n tt_p = self.generate_data(np.array([self.theta_fid for i in \n range(self.n_train * self.n_p)])\n , train = self.delta_theta, flatten = self.flatten\n , noiseless_deriv = self.noiseless_deriv)\n # Central sim\n np.random.seed(seed)\n tt = self.generate_data(np.array([self.theta_fid for i in \n range(self.n_train * self.n_s)])\n , train = None, flatten = self.flatten)\n \n # np.random.seed()\n \n # derivative data\n tt_d = (tt_p - tt_m) / (2. * self.delta_theta)\n\n data[\"validation_data\"] = tt \n data[\"validation_data_d\"] = tt_d\n\n # for plotting purposes we save the upper/lower separately\n data[\"x_m_test\"], data[\"x_p_test\"] = tt_m, tt_p \n\n return data","def diamond(N, D, rng):\n samples = rng.randn(N, D)\n norm = np.sum(np.abs(samples), axis=1)\n return samples/norm[:,None]","def createFromData(data, r):\n m = DensityEstimator()\n #print \"Creating denisty estimator from data...\"\n\n m.mixture_dimensions = data.shape[1]\n m.dataset_size = data.shape[0]\n m.threshold = r\n \n # Normalisation of the data set\n m.normalisation_vector_min = np.array([0.0]*data.shape[1])\n m.normalisation_vector_max = np.array([0.0]*data.shape[1])\n for i in range(0, data.shape[1]):\n #data[:, i] -= min(data[:, i])\n #print i, \": \", max(data[:, i])\n m.normalisation_vector_min[i] = min(data[:, i]) \n m.normalisation_vector_max[i] = max(data[:, i])\n if m.normalisation_vector_min[i] == m.normalisation_vector_max[i]:\n m.normalisation_vector_min[i] = 0.0\n \n #data[:, i] -= m.normalisation_vector_min[i]\n #data[:, i] /= (m.normalisation_vector_max[i] - m.normalisation_vector_min[i])\n #data[:, i] /= (m.normalisation_vector_max[i] )\n #print m.normalisation_vector[i]\n #return\n \n # Split into clusters / kernels\n t=set()\n d=set(range(0,data.shape[0]))\n def get_random():\n sample = random.randint( 0, data.shape[0]-1 )\n while sample in t:\n sample = random.randint( 0, data.shape[0] - 1 )\n t.add(sample)\n return sample\n \n sets=[]\n while len(t)<data.shape[0]:\n i = get_random()\n sets.append(set([i]))\n #print \"Cluster at\", i, \n for j in d-t:\n if np.sqrt(sum((data[i,:]-data[j,:])**2)) < r:\n sets[-1].add(j)\n t.add(j)\n #print \"members = \", len (sets[-1])\n new_set = list()\n for i in sets[-1]:\n new_set.append(data[i, :])\n sets[-1] = np.array(new_set)\n \n #print \"Cluster count=\",len(sets)\n #for i in sets:\n #print 'sets: ',i\n \n # Turn each cluster into a Gaussian kernel\n\n # Any set that has less than 3 members merge with nearests\n minimum_members = 2 #data.shape[1] # mixture dimensions to avoid singular covariance.\n #print sets\n #for i in sets:\n #if len(i) < minimum_members:\n #print \"Small set \"\n #for pt in i:\n #close = [None, 1e100000]\n #for j in sets:\n ##print i\n #print j\n #if (i == j).all():\n #print \"same\"\n #continue\n #print \"diff\"\n #if len(j) < minimum_members:\n #continue # err, bad, should allow possibile join smalls\n #mu = np.sum(i, 0) / (1.0 * i.shape[0])\n #dist = sum([(m - p)**2 for m, p in zip(mu, pt)])\n #print dist\n #if dist < close[1]:\n #close[1] = dist\n #close[0] = j\n #close[0].add(pt)\n \n \n m.kernels = []\n for i in sets:\n if len(i) >= minimum_members:\n m.kernels.append(GaussKernel(i, i.shape[0]/(1. * data.shape[0])))\n else:\n print \"LOST SOME\"\n #else:\n #print \"->Warning: dropping data point as it lies alone, singular\"\n #print \"ok.\"\n return m","def createDist(N):\n return np.random.normal(loc=1000.,scale=5.,size=np.random.poisson(lam=N))","def generateModelData(params, standoffDistance, nSamples):\n initialEnergy, eLoss, e2, e3, sigma = params\n \n data_x=np.random.uniform(low=0.0, high=distance_cellLength, size=nSamples)\n meanEnergy = initialEnergy + eLoss*data_x + \\\n e2*np.power(data_x,2) + e3 * np.power(data_x,3)\n data_ed= np.random.normal(loc=meanEnergy, scale=sigma)\n data_en = getDDneutronEnergy(data_ed)\n \n neutronDistance = standoffDistance + (distance_cellLength - data_x) + \\\n distance_zeroDegLength/2\n neutronTOF = getTOF(mass_neutron, data_en, neutronDistance)\n effectiveDenergy = (initialEnergy + data_ed)/2\n deuteronTOF = getTOF( mass_deuteron, effectiveDenergy, data_x )\n data_tof = neutronTOF + deuteronTOF\n \n data = np.column_stack((data_x,data_ed,data_en,data_tof))\n return data","def deng_random(seeds):\n\n x = seeds[0]\n y = seeds[1]\n\n while 0<1:\n temp = x\n x = (x + y) % 1.0\n y = temp\n yield x","def build_data(seed):\n rs = np.random.RandomState(seed)\n\n def y(x):\n \"\"\" y(x) = 1 + 0.3 * x_1 - 0.6 * x_2^2 - 0.2 * x_3^3 + 0.5 x_4^4 \"\"\"\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4\n\n xtrain = rs.rand(10000, 4)\n xtest = rs.rand(1000, 4)\n ytrain = y(xtrain) + rs.rand(10000) / 10\n ytest = y(xtest) + rs.rand(1000) / 10\n return xtrain, xtest, ytrain, ytest","def generate(self, n, d):\n\n self.n = n\n self.d = d\n self.X = np.random.rand(n, d)\n self.Y = np.random.choice([0, 1], size=n)","def sample_deltas(self, number):\n return (torch.randn(number, 1) + self.delta_mean) * self.delta_std","def generate_points(self):\n for x in range(self.num_sides):\n for y in range(self.num_sides):\n for z in range(self.num_sides):\n col_name = y + 4\n top_num = 0\n if 1 < z < 4:\n top_name = 'b'\n else:\n top_name = 'd'\n if z == 3 or z == 1:\n top_num += 4\n top_num += x\n\n top_name += str(top_num)\n\n k = Node(x*self.length-self.center, y*self.length -\n self.center, z*self.length-self.center, top_name, col_name)\n self.c_layers[y].append(k)\n self.points.append(k)","def perturb_points(points,\n z_vals,\n ray_directions,\n device):\n distance_between_points = z_vals[:, :, 1:2, :] - z_vals[:, :, 0:1, :] # (n, num_rays, 1, 1)\n offset = (torch.rand(z_vals.shape, device=device) - 0.5) \\\n * distance_between_points # [-0.5, 0.5] * d, (n, num_rays, n_samples, 1)\n z_vals = z_vals + offset\n\n points = points + \\\n offset * ray_directions.unsqueeze(2) # (n, num_rays, n_samples, 3)\n return points, z_vals","def generate_random_DC_MT():\n # Specify DC moment tensor to rotate:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n # And rotate DC moment tensor by random 3D angle:\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\n # And normallise so that moment tensor magnitude = 1:\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\n return random_DC_six_MT_normalised","def Generate_Random( self ):\n print( 'Generating Random coordinates' )\n stands = self.Data.Stand.keys()\n stands.sort()\n for s in stands:\n trees = self.Data.Stand[s].Tree.keys()\n trees.sort()\n for t in trees:\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def gen_data(min_coord, max_coord, size):\r\n data = np.random.randint(min_coord, max_coord, size)\r\n return data","def derandomize(self, xs, noises):\n raise NotImplementedError","def initialization(n, D):\n\n samples = []\n while len(samples) < n:\n # X = np.random.randint(0, D.shape[1], 10*n)\n # Y = np.random.randint(0, D.shape[0], 10*n)\n X = np.random.uniform(0, D.shape[1], 10*n)\n Y = np.random.uniform(0, D.shape[0], 10*n)\n P = np.random.uniform(0, 1, 10*n)\n index = 0\n while index < len(X) and len(samples) < n:\n x, y = X[index], Y[index]\n x_, y_ = int(np.floor(x)), int(np.floor(y))\n if P[index] < D[y_, x_]:\n samples.append([x, y])\n index += 1\n return np.array(samples)","def Gen_directed_diff(D, dt, vs, sigmaDM, Ns, beta_set=None, withlocerr=True):\n traces = []\n for v, n, sig in zip(vs, Ns, sigmaDM):\n if beta_set is None:\n beta = np.random.uniform(0, 2 * np.pi)\n else:\n beta = beta_set\n dx, dy = v * dt * np.cos(beta), v * dt * np.sin(beta)\n\n xsteps = np.random.normal(0, np.sqrt(2 * D * dt), size=n) + dx\n ysteps = np.random.normal(0, np.sqrt(2 * D * dt), size=n) + dy\n\n x, y = (\n np.concatenate([[0], np.cumsum(xsteps)]),\n np.concatenate([[0], np.cumsum(ysteps)]),\n )\n if withlocerr:\n x_noisy, y_noisy = (\n x + np.random.normal(0, sig, size=x.shape),\n y + np.random.normal(0, sig, size=y.shape),\n )\n traces.append(np.array([x_noisy, y_noisy]).T)\n else:\n traces.append(np.array([x, y]).T)\n return traces","def sample_rademacher(shape, dtype, seed_pair):\n rand_uniform = tf.random.stateless_uniform(shape=shape, seed=seed_pair)\n return tf.cast(tf.sign(rand_uniform - 0.5), dtype)","def generate_data(self):\n\n # cfg.d_sour_num = 20 # number of source domains\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\n # cfg.d_targ_num = 1 # number of target domain\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\n\n\n # cfg.train_num = 100 # number of training point in each domain\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\n\n # cfg.val_num = 100\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\n\n # cfg.support_num = 10\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\n\n # cfg.test_num = 100\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\n\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)","def generateData(N, k):\n n = float(N) / k\n X = []\n for i in range(k):\n c = (random.uniform(-1, 1), random.uniform(-1, 1))\n s = random.uniform(0.05, 0.5)\n x = []\n while len(x) < n:\n a, b = np.array([np.random.normal(c[0], s), np.random.normal(c[1], s)])\n # Continue drawing points from the distribution in the range [-1,1]\n if abs(a) < 1 and abs(b) < 1:\n x.append([a, b])\n X.extend(x)\n X = np.array(X)[:N]\n # Write list to file for later use\n f = open('./dataset_N' + str(N) + '_K' + str(k) + '.txt', 'w')\n for x in X:\n f.write(str(x[0]) + \" \" + str(x[1]) + '\\n')\n\n f.close();\n\n return X","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def randomdir(N=1):\n\t#r = p1.sampler(rmax)\n\tphi = random.random(size=N) * 2 * pi\n\t#theta = arccos(random.random()#\n\tcostheta = random.random(size=N) * 2 - 1\n\t#sintheta = sqrt(1-costheta**2)\n\treturn phi, arccos(costheta)","def run_gradient_descent(seed=0):\n random.seed(seed)\n colors = [color for color in matplotlib.colors.cnames]\n\n def random_point():\n return (2 * random.random() - 1, 2 * random.random() - 1)\n\n def df(x_i):\n \"\"\"this is the gradient of x^2 + y^2\"\"\"\n return [2 * x_ij for x_ij in x_i]\n\n for color in random.sample(colors, 50):\n path = take(10, gradient_descent(df, random_point()))\n for i, (x, y) in enumerate(path):\n plt.plot(x, y, color=color, marker='*', markersize=20-2*i)\n\n plt.show()","def create_dataset(name, grid=None, samples=1000, seed=0):\n if grid == None:\n np.random.seed(seed)\n points = 1 - 2 * np.random.rand(samples, 2)\n else:\n x = np.linspace(-1, 1, grid)\n points = np.array(list(product(x, x)))\n creator = globals()[f\"_{name}\"]\n\n x, y = creator(points)\n return x, y","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def random(cls, d=2, borns=[-1, 1], **kwargs):\n p1 = Point.random(d, borns)\n p2 = Point.random(d, borns)\n return cls(*[p1, p2], **kwargs)","def generate_points(num_points):\n for i in xrange(0, num_points):\n pass","def random_projection_cosine_split(data, indices, rng_state):\n dim = data.shape[1]\n\n # Select two random points, set the hyperplane between them\n left_index = tau_rand_int(rng_state) % indices.shape[0]\n right_index = tau_rand_int(rng_state) % indices.shape[0]\n right_index += left_index == right_index\n right_index = right_index % indices.shape[0]\n left = indices[left_index]\n right = indices[right_index]\n\n left_norm = norm(data[left])\n right_norm = norm(data[right])\n \n if left_norm == 0.0:\n left_norm = 1.0\n \n if right_norm == 0.0:\n right_norm = 1.0\n\n # Compute the normal vector to the hyperplane (the vector between\n # the two points)\n hyperplane_vector = np.empty(dim, dtype=np.float32)\n\n for d in range(dim):\n hyperplane_vector[d] = ((data[left, d] / left_norm) -\n (data[right, d] / right_norm))\n\n hyperplane_norm = norm(hyperplane_vector)\n if hyperplane_norm == 0.0:\n hyperplane_norm = 1.0\n \n for d in range(dim):\n hyperplane_vector[d] = hyperplane_vector[d] / hyperplane_norm\n\n # For each point compute the margin (project into normal vector)\n # If we are on lower side of the hyperplane put in one pile, otherwise\n # put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n n_left = 0\n n_right = 0\n side = np.empty(indices.shape[0], np.int8)\n for i in range(indices.shape[0]):\n margin = 0.0\n for d in range(dim):\n margin += hyperplane_vector[d] * data[indices[i], d]\n\n if margin == 0:\n side[i] = tau_rand_int(rng_state) % 2\n if side[i] == 0:\n n_left += 1\n else:\n n_right += 1\n elif margin > 0:\n side[i] = 0\n n_left += 1\n else:\n side[i] = 1\n n_right += 1\n\n # Now that we have the counts allocate arrays\n indices_left = np.empty(n_left, dtype=np.int64)\n indices_right = np.empty(n_right, dtype=np.int64)\n\n # Populate the arrays with indices according to which side they fell on\n n_left = 0\n n_right = 0\n for i in range(side.shape[0]):\n if side[i] == 0:\n indices_left[n_left] = indices[i]\n n_left += 1\n else:\n indices_right[n_right] = indices[i]\n n_right += 1\n\n return indices_left, indices_right","def generate_data(func, points, seed=0):\n np.random.seed(seed)\n\n data = []\n for segment in points:\n x = np.linspace(*segment[\"xlim\"], num=segment[\"n_points\"])\n distribution = func(x)\n # Generate observations\n y = distribution.rvs()\n df = pd.DataFrame({\"x\": x, \"y\": y})\n data.append(df)\n\n return pd.concat(data, ignore_index=True)","def distance_dmc(distances, Ks, points):\n doors = []\n for d in distances:\n dmc = []\n for k in Ks:\n print \"==========================\", k, \"==========================\"\n clusters = create_clusters(25, k)\n\n kmeans(points, clusters)\n # print \"Finished creating kmeans algorithm\"\n\n create_backbone_network(GRAPH, clusters, d)\n # print \"Finished creating backbone network\"\n\n find_all_shortest_paths(clusters, SP_TABLE, GRAPH)\n # print \"Finished finding all shortest paths\"\n\n for clst in clusters:\n clst.inter_cost = inter_cost(clst)\n clst.intra_cost = intra_cost(points, clst)\n clst.dm_cost = door_matt_cost(clusters, clst, SP_TABLE)\n\n ret = total_cost(clusters)\n dmc.append(ret[2])\n doors.append(sum(dmc))\n draw_door_matts(map(lambda d: float(format(d, \".4g\")), distances), doors)","def sample(self, d):\n dist = rnd.uniform(0,self.length)\n w = rnd.normal(0,self.width)\n d.pos = np.dot(rotmat(self.angle), [dist, w]) + self.pos\n d.ownpos = self.pos","def make_pnts(start_point, end_point, path, cellsize):\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\n \n #Only do sampling at DEM with >3m resolution \n if cellsize[0] >= 5:\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\n return pnts","def generate_normal_data(avg_strike, avg_dip, n=10, noise_std=5, porp=2):\n opp_strike = avg_strike + 180\n if opp_strike > 360: \n opp_strike -= 360\n strike = avg_strike * np.ones(n)\n strike[n//porp:] = opp_strike\n dip = avg_dip * np.ones(n)\n \n # Add noise\n strike += noise_std * np.random.randn(n)\n dip += noise_std * np.random.randn(n)\n\n # Filter out things out of a reasonable range\n strike[dip > 90] -= 180\n dip[dip > 90] = 180 - dip[dip>90]\n\n strike[dip < 0] -= 180\n dip[dip < 0] *= -1\n\n strike[strike < 0] += 360\n strike[strike > 360] -= 360\n \n\n normal = geometric_functions.plane2normal(strike, dip)\n slip = geometric_functions.normal_slip(*normal)\n\n return strike, dip, normal, slip","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def _generate_data(self,\n batch_size: int = 1,\n num_keypoints: int = 5,\n norm_item: str = 'box_size') -> tuple:\n data_batch = []\n data_samples = []\n\n for i in range(batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % batch_size, 0] = False\n gt_instances[norm_item] = np.random.random((1, 1)) * 20 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n data_batch.append(data)\n data_samples.append(data_sample)\n\n return data_batch, data_samples","def generate_data(self, s=0):\n np.random.seed(s)\n \n L_b = np.linalg.cholesky(self.cov_b)\n L_t = np.linalg.cholesky(self.cov_t)\n \n self.x_benchmark = np.dot(L_b,(np.random.randn(self.n_points,2) + self.mean_b).T).T\n self.x_trial = np.dot(L_t,(np.random.randn(self.n_points,2) + self.mean_t).T).T","def generate_parameters(self, cluster_center, std_dev, num_tasks):\n return np.random.normal(cluster_center, std_dev, num_tasks)","def create_panel_of_normals(paths, N, name):\n dfs = [ pd.read_table(paths[0]) ]\n for i, path in enumerate(paths[1:]):\n df_to_concat = pd.read_table(path)\n dfs.append(df_to_concat)\n df = pd.concat(dfs, axis=0)\n # Shuffle samples to pick from all batches\n df = df.sample(frac=1).reset_index(drop=True)\n normals = df[df.sample_type==\"Normal\"][:N]['sample_id']\n if N==-1: print (\"Creating panel of %d normals\" %normals.shape[0])\n else: print (\"Creating panel of %d normals\" %N)\n \n # Compile data\n data = pd.concat([pd.DataFrame(index=normals.index, columns=['membership:sample_set_id'], data=name), \\\n normals], axis=1)\n\n return data","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 generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def __generate_spawn_points(self):\n while True:\n p1x = random.randint(0, self.width - 1)\n p1y = random.randint(0, self.height - 1)\n p2x, p2y = self.__mirror(p1x, p1y)\n d_sq = (p1x - p2x)**2 + (p1y - p2y)**2\n if d_sq >= (self.width / 2)**2:\n break\n return (p1x, p1y), (p2x, p2y)","def generate_scatter(dm):\n # This section places something on the surface every few units -- good for testing out the get_height method\n scatter_offset = 128\n for x in range((map_center[0] - map_size[0] // 2) + scatter_offset, (map_center[0] + map_size[0] // 2), scatter_offset):\n for y in range((map_center[1] - map_size[1] // 2) + scatter_offset, (map_center[1] + map_size[1] // 2),\n scatter_offset):\n\n slope_angle = math.degrees(dm.get_slope(dm.get_relative_position((x,y))))\n h = ground.get_height((x, y))\n\n if water_height - 64 < h < water_height - 32 and random.randrange(20) == 0:\n # This spot is in shallow water, so spawn a boat. (spawn it slightly higher than water level, so that it can float)\n base.PropPhysics(m, origin=Origin(x, y, water_height + 8),\n angles=Origin(0, random.randrange(360), 0),\n model=\"models/props_canal/boat001{0}.mdl\".format((\"a\", \"b\")[random.randrange(2)]))\n elif water_height + 128 < h and random.randrange(15) == 0 and slope_angle < 30:\n # We have a flat area somewhat away from the shore, so we can put a tree here.\n base.PropStatic(m, origin=Origin(x, y, h - 3),\n model=\"models/props_foliage/tree_deciduous_0{0}a.mdl\".format(random.randrange(3) + 1),\n angles=Origin(0, random.randrange(360), 0), skin=1)","def rand_raster(center, step_size, num_points, random):\n xscan = []\n yscan = []\n \n xcenter = center[0] # first element of center array\n ycenter = center[1] # second element of center array\n \n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\n \n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\n \n # Creates two arrays xscan and yscan\n for step, ystep in enumerate(yrange):\n xscan.append(xrange[::(-1)**step])\n yscan.append(np.ones_like(xrange) * ystep)\n \n xscan = np.concatenate(xscan)\n yscan = np.concatenate(yscan)\n \n # Combine the two arrays into a list of vectors\n raster = []\n \n for i in range(0, len(xscan)):\n scan_element = []\n \n scan_element.append(xscan[i])\n scan_element.append(yscan[i])\n raster.append(scan_element)\n \n return raster","def generate(\n seeds=10,\n param_num_nodes=7,\n mode='train',\n param_dim=10,\n param_sel=100,\n param_mu=10,\n param_br=0.05,\n param_activity_wt=None,\n A=None,\n sp_to_id=None,\n min_coord=None,\n max_coord=None,\n org_pts=None,\n ):\n global dim, sel, mu, br, activity_wt, tree_lc, tree_rc, num_nodes\n\n dim=param_dim\n sel=param_sel\n mu=param_mu\n br=param_br\n activity_wt=param_activity_wt\n num_nodes = param_num_nodes\n\n sp_root = 0\n tree = None\n\n if mode == 'train':\n tree, tree_lc, tree_rc = generate_tree(sp_root, num_nodes)\n if param_activity_wt is None:\n # weights for the linear activity function\n num_wts = int(((dim * (dim + 1))/2) + 1)\n activity_wt = np.random.normal(0, 1, num_wts)\n\n if org_pts is None:\n org_pts = []\n # simulate data points\n # format: exampleID, species, values\n # region, species, coord1, coord2, ...., activity_value\n\n for i in tqdm(range(int(seeds))):\n pt_id = i\n\n # pick a random point of d-dimension\n rand_pt = np.random.uniform(min_coord, max_coord, dim)\n curr_pt = np.append([pt_id, sp_root], rand_pt)\n curr_activity = get_activity(modify_pt(rand_pt), activity_wt)\n # print('curr_pt:', curr_pt, 'curr_activity:', curr_activity); exit(0)\n org_pts.append(np.append(curr_pt, curr_activity))\n\n generated_points = []\n full_org_pts = []\n\n if mode == 'train':\n pool = Pool(16)\n sample_bag = pool.map(generate_bag, org_pts)\n for item in sample_bag:\n for val in item:\n val = list(val)\n full_org_pts.append(val)\n generated_points.append(val[:2]+modify_pt(val[2:-1])+[val[-1]])\n else:\n for val in org_pts:\n val = list(val)\n generated_points.append(val[:2]+modify_pt(val[2:-1])+[val[-1]])\n\n return generated_points, activity_wt, org_pts, full_org_pts, tree","def plane_generator():\n\n planarRadius = np.sqrt(N / (np.pi * pointDensity)) # <-- convert pointDensity into radius\n planarThreshold = planarRadius * np.sqrt(thresholdFrac)\n\n # distance function (law of cosines)\n def dist(rTheta1, rTheta2): # rThetai is a coordinate tuple: (r, theta)\n a, b = rTheta1[0], rTheta2[0]\n theta1, theta2 = rTheta1[1], rTheta2[1]\n return np.sqrt(a ** 2 + b ** 2 - 2 * a * b * np.cos(theta1 - theta2)) # <-- law of cosines\n\n # computes the adjacency matrices\n data_plane = []\n for r in range(num_graphs):\n\n # generates dictionary of positions for each node: node_pos = {node_i: (radius, theta)}\n node_pos = {}\n for i in range(N):\n rnd_angle = np.random.random() * 2 * np.pi\n rnd_radii = np.random.random() * planarRadius\n node_pos.update({i: (rnd_radii, rnd_angle)})\n\n Adj_Matrix = np.zeros((N, N))\n for i in range(N):\n for j in range(N):\n ij_dist = dist(node_pos[i], node_pos[j])\n if ij_dist < planarThreshold:\n Adj_Matrix[i, j] = 1 # nodes that are connected are assigned a 1 in the matrix\n\n data_plane.append(Adj_Matrix)\n\n return data_plane","def generate_test():\n o = []\n pos = [384, 288]\n note_group_size = GAN_PARAMS[\"note_group_size\"]\n generate_set(begin=3 * note_group_size, start_pos=pos,\n length_multiplier=dist_multiplier, group_id=3, plot_map=True)","def DeviatoricGridRandom(magnitudes=[1.], npts=100000):\n\n v = random(-1./3., 1./3., npts)\n w = np.zeros(npts)\n kappa = random(0., 360, npts)\n sigma = random(-90., 90., npts)\n h = random(0., 1., npts)\n rho = list(map(to_rho, asarray(magnitudes)))\n\n v = np.tile(v, len(magnitudes))\n w = np.tile(w, len(magnitudes))\n kappa = np.tile(kappa, len(magnitudes))\n sigma = np.tile(sigma, len(magnitudes))\n h = np.tile(h, len(magnitudes))\n rho = np.repeat(rho, npts)\n\n return UnstructuredGrid(\n dims=('rho', 'v', 'w', 'kappa', 'sigma', 'h'),\n coords=(rho, v, w, kappa, sigma, h),\n callback=to_mt)","def generate_k(data_set, k):\n centers = []\n dimensions = len(data_set[0])\n min_max = defaultdict(int)\n\n for point in data_set:\n for i in range(dimensions):\n val = point[i]\n min_key = 'min_{0}d'.format(i)\n max_key = 'max_{0}d'.format(i)\n if min_key not in min_max or val < min_max[min_key]:\n min_max[min_key] = val\n if max_key not in min_max or val > min_max[max_key]:\n min_max[max_key] = val\n\n for _k in range(k):\n rand_point = []\n for i in range(dimensions):\n min_val = min_max['min_{0}d'.format(i)]\n max_val = min_max['max_{0}d'.format(i)]\n \n rand_point.append(uniform(min_val, max_val))\n centers.append(rand_point)\n return centers","def __init__(self):\n # start x position\n self.x = random.randrange(size_x)\n # start y position\n self.y = - random.randrange(100)\n # drift x (amount of change each loop along the x axis)\n self.dx = random.randrange(3) - random.randrange(6)\n # drift y (amount of change each loop along the y axis)\n self.dy = random.randrange(1, 20) + random.randrange(4)\n # the size of the circular snowflake\n self.size = random.randrange(1, 4)\n # the colour of the snowflake (from sludgy grey to snowy white)\n c = random.randrange(200, 256)\n self.color = [c, c, c]","def test_d_3():\n rs = 20\n d = 3\n np.random.seed(rs)\n number_rotations = 3\n\n theta_1 = np.random.uniform(0, 2 * math.pi)\n rotation_1 = np.identity(d)\n pos_1 = np.random.randint(0, d - 1)\n pos_2 = np.random.randint(pos_1 + 1, d)\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\n\n theta_2 = np.random.uniform(0, 2 * math.pi)\n rotation_2 = np.identity(d)\n pos_3 = np.random.randint(0, d - 1)\n pos_4 = np.random.randint(pos_3 + 1, d)\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\n\n theta_3 = np.random.uniform(0, 2 * math.pi)\n rotation_3 = np.identity(d)\n pos_5 = np.random.randint(0, d - 1)\n pos_6 = np.random.randint(pos_5 + 1, d)\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\n\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\n np.random.seed(rs)\n rotation_function = (mt_obj.calculate_rotation_matrix\n (d, number_rotations))\n assert(np.all(final_rotation == rotation_function))","def create_distortions(self, x1, y1, x2, y2):\n if not self.distortions:\n return [x1, y1, x2, y2]\n\n angle_perpendicular = self.angle + 90.0\n points = len(self.distortions)\n\n segments = [x1, y1]\n\n # For 3 points, we have: x = (3x1 + x2) / 4, (2x1 + 2x2) / 4, (x1 + 3x2) / 4\n for i, distortion in enumerate(self.distortions):\n xpos = ((points - i) * x1 + (i + 1) * x2) / (points + 1)\n ypos = ((points - i) * y1 + (i + 1) * y2) / (points + 1)\n segments.extend(move_point(xpos, ypos, angle_perpendicular, self.distance * distortion))\n\n segments.extend([x2, y2])\n\n return segments","def make_travel_dataset():\n util.make_dataset_dmoz(\n n_items=600,\n seed=0,\n category_parent='Top/Recreation/Travel',\n rawdir=os.environ['DMOZ_TRAVEL_RAW'],\n webdir=os.environ['DMOZ_TRAVEL_WEB'],\n )","def __create_sample_data__(npts = 20):\n\t#data function\n\tdef wavy(x, y):\n\t\treturn np.sin(0.2*np.pi*x)*np.cos(0.4*np.pi*y)\n\t\n\t#make grid\n\txs = np.linspace(0, 2*20, 2*npts + 1)\n\tys = np.linspace(0, 20, npts + 1)\n\t(xgrid, ygrid) = np.meshgrid(xs, ys)\n\tzgrid = wavy(xgrid, ygrid)\n\t\n\treturn (xgrid, ygrid, zgrid)","def generate_random_data(size, x_min=X_MIN, x_max=X_MAX, y_min=Y_MIN, y_max=Y_MAX):\n result = []\n for _i in range(size):\n result.append((randint(x_min, x_max), randint(y_min, y_max)))\n\n return result","def generate_self_collision_dataset(start, num_joints, num_points):\n total_number_points = 0\n\n # import environment\n empty_environment()\n\n # initialize validity check\n space = initialize_space()\n ss = og.SimpleSetup(space)\n state_validity_checker = MoveitOMPLStateValidityChecker(ss.getSpaceInformation())\n\n # header for the dataset\n limb_name = 'right'\n header_written = False\n header = get_joint_names(limb_name) + [SELF_COLLISION_KEY]\n\n directory = DIRECTORY % \"empty_environment\"\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n file_name = os.path.join(directory, get_file_name(limb_name, num_joints, num_points, start))\n\n # statistics for tracking generation\n batch_time = []\n\n for i in range(0, int(math.ceil(float(num_points) / BATCH_SIZE))):\n print(\"Elasped time: %s\" % (time.time() - start))\n print(\"Start generating data for batch: %s\" % (i + 1))\n batch_start = i * BATCH_SIZE\n batch_end = batch_start + BATCH_SIZE\n size = BATCH_SIZE\n\n if batch_end >= num_points:\n # We've come to the last batch\n size = num_points - batch_start\n\n batch_time_start = time.time()\n\n samples = generate_configs(size, state_validity_checker, limb_name)\n\n with open(file_name, mode='a') as csv_file:\n # Quote header such that it is easier for reader to parse data\n writer = csv.DictWriter(csv_file, fieldnames=header, quoting=csv.QUOTE_NONNUMERIC)\n if not header_written:\n writer.writeheader()\n header_written = True\n writer.writerows(samples)\n total_number_points += size\n\n # Save time to generate batch for later statistics\n batch_time_end = time.time()\n batch_time.append(batch_time_end - batch_time_start)\n\n # output statistics;\n end = time.time()\n total_time = end - start\n print(\"Finished generating self-collision dataset. \" +\n \"Total time elapsed: %s; Total number of points: %s\" % (total_time, total_number_points))\n print(\"Average time to produce a batch of size %s: %s\" % (\n BATCH_SIZE, reduce(lambda x, y: x + y, batch_time) / len(batch_time)))\n return file_name","def __init__(self, sample_size, neighbours, lengths, offsets, seed=0):\n self.sample_size = sample_size\n self.seed, self.seed2 = random_seed.get_seed(seed)\n self.neighbours = neighbours\n self.lengths = lengths\n self.offsets = offsets\n super(UniformEdgeDataset, self).__init__()","def dyn_trajectory(Tinit, delT, n):\n Titer = Tinit\n # note that copy is necessary, otherwise delPos is just a view on delT\n # which causes it to change when delT changes\n delPos = delT[:2, 2:3].copy() \n for i in xrange(n):\n tmp = Titer\n positer = Titer[:2, 2:3]\n # Center of rotation is around around positer (TODO: accept it as\n # paramter)\n delT[:2, 2:3] = delPos -delT[:2, :2].dot(positer) + positer \n Titer = delT.dot(Titer)\n yield tmp","def build_toy_dataset(N):\n y_data = np.random.uniform(-10.5, 10.5, N)\n r_data = np.random.normal(size=N) # random noise\n x_data = np.sin(0.75 * y_data) * 7.0 + y_data * 0.5 + r_data * 1.0\n x_data = x_data.reshape((N, 1))\n return train_test_split(x_data, y_data, random_state=42)","def generate_two_dim_multi_type4(self, num_data):\n mu_before = np.random.choice(self.num_interval, size=[num_data * 3, 2])\n r = np.random.exponential(scale=10, size=[num_data * 3])\n theta = np.random.uniform(low=0, high=2 * math.pi, size=[num_data * 3])\n\n mu_after = np.zeros(shape=mu_before.shape, dtype=np.float32)\n mu_after[:, 0] = mu_before[:, 0] + r * np.cos(theta)\n mu_after[:, 1] = mu_before[:, 1] + r * np.sin(theta)\n mu_after = np.around(mu_after).astype(np.int)\n\n select_id = np.where((mu_after[:, 0] >= 0) & (mu_after[:, 0] <= self.num_interval) &\n (mu_after[:, 1] >= 0) & (mu_after[:, 1] <= self.num_interval))[0][:num_data]\n\n mu_before, mu_after = mu_before[select_id], mu_after[select_id]\n vel = np.sqrt(np.sum((mu_after - mu_before) ** 2, axis=1)) * self.interval_length\n\n place_pair = {'before': mu_before, 'after': mu_after, 'vel': vel}\n return place_pair\n\n # def generate_two_dim_test(self, num_data, velocity, num_step):\n # mu_seq = np.zeros(shape=[num_data, 2], dtype=np.int32)\n # vel_pool = np.where((self.velocity[:, 0] >= -1) & (self.velocity[:, 1] >= -1))\n # vel_idx = np.random.choice(vel_pool[0], size=num_data)\n # vel = np.zeros(shape=[num_data, 2], dtype=np.float32)\n #\n # mu = [6, 6]\n #\n # for i in range(num_data):\n # mu_seq[i] = mu\n # v_idx = vel_idx[i]\n # v = self.velocity[v_idx]\n # mu = mu + v\n # vel[i] = v * self.interval_length\n #\n # vel_idx.astype(np.int32)\n #\n # place_data = {'place_seq': mu_seq, 'vel_idx': vel_idx, 'vel': vel}\n # return place_data","def generate_base_points(num_points, domain_size, density_map=None,\n reflect=True):\n\n def _try_points(num_points, prob):\n prob = np.atleast_3d(prob)\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\n base_pts = []\n N = 0\n while N < num_points:\n pt = np.random.rand(3) # Generate a point\n # Test whether to keep it or not\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\n if np.random.rand(1) <= prob[indx][indy][indz]:\n base_pts.append(pt)\n N += 1\n base_pts = np.array(base_pts)\n return base_pts\n\n if len(domain_size) == 1: # Spherical\n domain_size = np.array(domain_size)\n r = domain_size[0]\n if density_map is None:\n # Make an image of a sphere filled with ones and use _try_points\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, 20] = 0\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to spherical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\n # Reflect base points across perimeter\n if reflect:\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_spherical(r, theta, phi)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 2: # Cylindrical or Disk\n domain_size = np.array(domain_size)\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n density_map[20, 20, :] = 0\n if domain_size[1] == 0: # Disk\n density_map = density_map[:, :, 0]\n density_map = spim.distance_transform_edt(density_map) < 20\n base_pts = _try_points(num_points, density_map)\n # Convert to cylindrical coordinates\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\n theta = 2*np.arctan(Y/X)\n z = Z*domain_size[1]\n # Trim points outside the domain (from improper prob images)\n inds = r <= domain_size[0]\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n inds = ~((z > domain_size[1]) + (z < 0))\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\n if reflect:\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\n domain_size)\n # Convert to Cartesean coordinates\n X, Y, Z = from_cylindrical(r, theta, z)\n base_pts = np.vstack([X, Y, Z]).T\n\n elif len(domain_size) == 3: # Cube or square\n if density_map is None:\n density_map = np.ones([41, 41, 41])\n if domain_size[2] == 0:\n density_map = density_map[:, :, 0]\n base_pts = _try_points(num_points, density_map)\n base_pts = base_pts*domain_size\n if reflect:\n base_pts = reflect_base_points(base_pts, domain_size)\n\n return base_pts","def get_germes_regular(img, nb_points):\n print(\"============================\")\n print(\"Seed selection\")\n\n germes = []\n dist_between_pts = img.shape[0] * img.shape[1] // nb_points\n\n for i in range(nb_points):\n # on ajoute une petite variation aleatoire\n diff_x = random.randint(-5, 5)\n diff_y = random.randint(-5, 5)\n\n n = dist_between_pts * i\n\n sx = n % img.shape[0] + diff_x\n sy = n // img.shape[0] + diff_y\n\n sx = max(min(sx, img.shape[0]-1), 0)\n sy = max(min(sy, img.shape[1]-1), 0)\n\n germes.append((sx, sy))\n\n return germes","def generate_random_surface_points() -> List[SurfacePoint]:\n surface_points: List[SurfacePoint] = []\n for _ in range(42):\n surface_point = SurfacePoint(\n idx=uuid.uuid4().hex,\n x=_gen_random_number(),\n y=_gen_random_number(),\n z=_gen_random_number(),\n x_uc_dist=DistUcEnum.uniform,\n x_uc=_gen_random_number(),\n y_uc_dist=DistUcEnum.uniform,\n y_uc=_gen_random_number(),\n z_uc_dist=DistUcEnum.uniform,\n z_uc=_gen_random_number(),\n smooth=0.01,\n formation=\"Formation_0\",\n )\n surface_points.append(surface_point)\n return surface_points","def new_density(points):\n inshape = points.shape\n points = points.view(-1, 3)\n out = []\n for p in points:\n if torch.all(p > 0.5) or torch.all(p < -0.5):\n out.append(torch.tensor([[1.0]]))\n else:\n out.append(torch.tensor([[0.0]]))\n return torch.cat(out).view(*inshape[:-1], 1).to(device)","def random_pred_test_data(size: int, seed: int = 4321):\n y_pred = tf.random.stateless_normal((size,), seed=(seed, 0))\n y_test = tf.random.stateless_normal((size,), seed=(seed, 1))\n return y_pred, y_test","def __randomize_data(self):\n times = map(lambda (t, _): t, self.data)\n coords = map(lambda (_, c): c, self.data)\n return zip(times, map(DataGen.__randomize_coord, coords))","def generate_edges(self):\n for i, n in enumerate(self.points):\n for i1, p in enumerate(self.points[i+1:]):\n d = 0\n differences = 0\n for x in range(3):\n d += math.fabs(n.xyz[x] - p.xyz[x])\n if math.fabs(n.xyz[x] - p.xyz[x]) != 0:\n differences += 1\n\n if differences > 1:\n continue\n\n if d == -1 * self.side_length or d == self.side_length:\n self.edges.append([i, i1 + i + 1])","def generate_curves(self, seed = None):\n num_context = tf.random_uniform(\n shape=[], minval=3, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\n\n # If we are testing we want to have more targets and have them evenly\n # distributed in order to plot the function.\n if self._testing:\n num_target = 400\n num_total_points = num_target\n x_values = tf.tile(\n tf.expand_dims(tf.range(-2., 2., 1. / 100, dtype=tf.float32), axis=0),\n [self._batch_size, 1])\n x_values = tf.expand_dims(x_values, axis=-1)\n # During training the number of target points and their x-positions are\n # selected at random\n else:\n num_target = tf.random_uniform(shape=(), minval=0, \n maxval=self._max_num_context - num_context,\n dtype=tf.int32, seed=seed)\n num_total_points = num_context + num_target\n x_values = tf.random_uniform(\n [self._batch_size, num_total_points, self._x_size], -2, 2, seed=seed)\n\n # Set kernel parameters\n # Either choose a set of random parameters for the mini-batch\n if self._random_kernel_parameters:\n l1 = tf.random_uniform([self._batch_size, self._y_size,\n self._x_size], 0.1, self._l1_scale)\n sigma_f = tf.random_uniform([self._batch_size, self._y_size],\n 0.1, self._sigma_scale)\n # Or use the same fixed parameters for all mini-batches\n else:\n l1 = tf.ones(shape=[self._batch_size, self._y_size,\n self._x_size]) * self._l1_scale\n sigma_f = tf.ones(shape=[self._batch_size,\n self._y_size]) * self._sigma_scale\n\n # Pass the x_values through the Gaussian kernel\n # [batch_size, y_size, num_total_points, num_total_points]\n kernel = self._gaussian_kernel(x_values, l1, sigma_f)\n\n # Calculate Cholesky, using double precision for better stability:\n cholesky = tf.cast(tf.cholesky(tf.cast(kernel, tf.float64)), tf.float32)\n\n # Sample a curve\n # [batch_size, y_size, num_total_points, 1]\n y_values = tf.matmul(\n cholesky,\n tf.random_normal([self._batch_size, self._y_size, num_total_points, 1], seed=seed))\n\n # [batch_size, num_total_points, y_size]\n y_values = tf.transpose(tf.squeeze(y_values, 3), [0, 2, 1])\n\n if self._testing:\n # Select the targets\n target_x = x_values\n target_y = y_values\n\n # Select the observations\n idx = tf.random_shuffle(tf.range(num_target), seed=seed)\n context_x = tf.gather(x_values, idx[:num_context], axis=1)\n context_y = tf.gather(y_values, idx[:num_context], axis=1)\n\n else:\n # Select the targets which will consist of the context points as well as\n # some new target points\n target_x = x_values[:, :num_target + num_context, :]\n target_y = y_values[:, :num_target + num_context, :]\n\n # Select the observations\n context_x = x_values[:, :num_context, :]\n context_y = y_values[:, :num_context, :]\n\n query = ((context_x, context_y), target_x)\n\n return NPRegressionDescription(\n query=query,\n target_y=target_y,\n num_total_points=tf.shape(target_x)[1],\n num_context_points=num_context)","def makePLDS(T, x_0, f, g, Dx, Dy):\n\tX = np.zeros((T, Dx))\n\tY = np.zeros((T, Dy))\n\n\tX[0] = x_0\n\tY[0] = g.sample(x_0)\n\tfor t in range(1,T):\n\t\tX[t] = f.sample(X[t-1])\n\t\tY[t] = g.sample(X[t])\n\treturn X, Y","def sample_dirichlet(alpha, batch_size=100):\n return np.random.dirichlet(alpha, batch_size)","def make_tutorial_data(n: int) -> pd.DataFrame:\n np.random.seed(1111)\n\n dataset = pd.DataFrame({\n \"id\": list(map(lambda x: \"id%d\" % x, np.random.randint(0, 100, n))),\n \"date\": np.random.choice(pd.date_range(\"2015-01-01\", periods=100), n),\n \"feature1\": np.random.gamma(20, size=n),\n \"feature2\": np.random.normal(40, size=n),\n \"feature3\": np.random.choice([\"a\", \"b\", \"c\"], size=n)})\n\n dataset[\"target\"] = (dataset[\"feature1\"]\n + dataset[\"feature2\"]\n + dataset[\"feature3\"].apply(lambda x: 0 if x == \"a\" else 30 if x == \"b\" else 10)\n + np.random.normal(0, 5, size=n))\n\n # insert some NANs\n dataset.loc[np.random.randint(0, n, 100), \"feature1\"] = nan\n dataset.loc[np.random.randint(0, n, 100), \"feature3\"] = nan\n\n return dataset"],"string":"[\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\\n self.n = n\\n self.d = d\\n\\n # 95% of data lies in a 2*sigma ball around the mean.\\n # For unit variance normal, the 2*sigma ball mean the centers\\n # should be at distance of 4 in the d dimensional space.\\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\\n cov = np.eye(d)\\n\\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\\n # print(dist_mean)\\n # cov = np.eye(d)\\n\\n frac = int(1 / pos_fraction)\\n\\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\\n\\n self.X = np.vstack((cluster1, cluster2))\\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\\n\\n # Make blobs\\n # if True:\\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)\",\n \"def prepare_data_for_d(self):\\n\\n center_nodes = []\\n neighbor_nodes = []\\n labels = []\\n for i in self.root_nodes:\\n if np.random.rand() < config.update_ratio:\\n # self.graph[i] = [neighbors of i]\\n pos = self.graph[i]\\n neg, _ = self.sample(i, self.trees[i], len(pos), for_d=True)\\n # print(\\\"tree_i_d: \\\", self.trees[i])\\n # print(\\\"neg_samples: \\\", neg)\\n # print(\\\"neg is: \\\", neg)\\n if len(pos) != 0 and neg is not None:\\n # positive samples\\n center_nodes.extend([i] * len(pos))\\n neighbor_nodes.extend(pos)\\n labels.extend([1] * len(pos))\\n\\n # negative samples\\n center_nodes.extend([i] * len(pos))\\n neighbor_nodes.extend(neg)\\n labels.extend([0] * len(neg))\\n # print(\\\"cen: \\\", center_nodes)\\n return center_nodes, neighbor_nodes, labels\",\n \"def generateData(numPoints,x,y):\\n\\tfor i in range(0,numPoints):\\n\\t\\tif (i % 2 == 0):\\n\\t\\t\\tx.append(random.normalvariate(25, 15))\\n\\t\\t\\ty.append(random.normalvariate(25, 15))\\n\\t\\t\\t \\n\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tx.append(random.normalvariate(75, 15))\\n\\t\\t\\ty.append(random.normalvariate(75, 15))\",\n \"def random_verts2D_deviation(vertices, delta_verts2d_dev_range=[-0.01, 0.01]):\\n batch_size = vertices.shape[0]\\n num_verts = vertices.shape[1]\\n device = vertices.device\\n\\n noisy_vertices = vertices.clone()\\n\\n l, h = delta_verts2d_dev_range\\n delta_verts2d_dev = (h - l) * torch.rand(batch_size, num_verts, 2, device=device) + l\\n noisy_vertices[:, :, :2] = noisy_vertices[:, :, :2] + delta_verts2d_dev\\n\\n return noisy_vertices\",\n \"def generate_samples(delta=1, n=32):\\n X = np.zeros((n, NROW * NCOL))\\n Y = np.zeros((n, NROW * NCOL))\\n for i in range(n):\\n x, y = generate_sample(delta)\\n X[i, :] = x\\n Y[i, :] = y\\n return X, Y\",\n \"def random_projection_split(data, indices, rng_state):\\n dim = data.shape[1]\\n\\n # Select two random points, set the hyperplane between them\\n left_index = tau_rand_int(rng_state) % indices.shape[0]\\n right_index = tau_rand_int(rng_state) % indices.shape[0]\\n right_index += left_index == right_index\\n right_index = right_index % indices.shape[0]\\n left = indices[left_index]\\n right = indices[right_index]\\n\\n # Compute the normal vector to the hyperplane (the vector between\\n # the two points) and the offset from the origin\\n hyperplane_offset = 0.0\\n hyperplane_vector = np.empty(dim, dtype=np.float32)\\n\\n for d in range(dim):\\n hyperplane_vector[d] = data[left, d] - data[right, d]\\n hyperplane_offset -= hyperplane_vector[d] * (\\n data[left, d] + data[right, d]) / 2.0\\n\\n # For each point compute the margin (project into normal vector, add offset)\\n # If we are on lower side of the hyperplane put in one pile, otherwise\\n # put it in the other pile (if we hit hyperplane on the nose, flip a coin)\\n n_left = 0\\n n_right = 0\\n side = np.empty(indices.shape[0], np.int8)\\n for i in range(indices.shape[0]):\\n margin = hyperplane_offset\\n for d in range(dim):\\n margin += hyperplane_vector[d] * data[indices[i], d]\\n\\n if margin == 0:\\n side[i] = tau_rand_int(rng_state) % 2\\n if side[i] == 0:\\n n_left += 1\\n else:\\n n_right += 1\\n elif margin > 0:\\n side[i] = 0\\n n_left += 1\\n else:\\n side[i] = 1\\n n_right += 1\\n\\n # Now that we have the counts allocate arrays\\n indices_left = np.empty(n_left, dtype=np.int64)\\n indices_right = np.empty(n_right, dtype=np.int64)\\n\\n # Populate the arrays with indices according to which side they fell on\\n n_left = 0\\n n_right = 0\\n for i in range(side.shape[0]):\\n if side[i] == 0:\\n indices_left[n_left] = indices[i]\\n n_left += 1\\n else:\\n indices_right[n_right] = indices[i]\\n n_right += 1\\n\\n return indices_left, indices_right\",\n \"def ddds(cloud, sample_size, presample=None, processes=10):\\n\\n #--------------------------------------------------------------------------\\n\\n ### Prep\\n\\n # Handle small point clouds\\n if cloud.shape[0] <= sample_size:\\n warn(\\\"(code 1) Point cloud is already <= desired sample size. \\\" +\\n \\\"No subsampling is performed.\\\")\\n return cloud\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Compute per-landmark local densities\\n\\n # Subsample randomly (for speed/memory efficiency)\\n if presample is not None:\\n cloud_presubs = random_subsample(cloud, presample)\\n else:\\n cloud_presubs = np.copy(cloud)\\n\\n # Compute distance of each subsampled point to the closest other point\\n # Note: `k=2` is necessary since `k=1` is the point itself.\\n tree = cKDTree(cloud)\\n NN_dists = tree.query(cloud_presubs, k=2, n_jobs=processes)[0][:,1]\\n\\n # Get the size of the local neighborhood\\n # which is `alpha * median(smallest_distances)`,\\n # where a good value for alpha is 5 according to SPADE\\n alpha = 5\\n NN_size = alpha * np.median(NN_dists)\\n\\n # Get the local density (LD) of each landmark\\n # ...which is the number of other landmarks in its local neighborhood\\n LDs = tree.query_ball_point(cloud, NN_size, n_jobs=processes) # Get indices\\n LDs = np.vectorize(len)(LDs) # Count\\n\\n # Define the target density (TD)\\n # Note: Good values according to SPADE: the 3rd or 5th percentile of LDs\\n # Note: This effectively defines how strongly the data will be subsampled\\n TD_percentile = 3\\n TD = np.percentile(LDs, TD_percentile)\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Perform density-dependent subsampling\\n\\n # Create p(keep_lm) probability vector\\n # Note: For each point i, the probability of keeping it is\\n # { 1 if LD_i < TD\\n # { TD / LD_i otherwise\\n p_keep = TD / LDs\\n p_keep[LDs<TD] = 1\\n\\n # Randomly decide if a landmark should be kept according to p(keep_lm)\\n rand = np.random.uniform(size=cloud.shape[0])\\n keep = p_keep >= rand\\n\\n # Index the lms to be kept\\n cloud_ddds = cloud[keep,:]\\n\\n\\n #--------------------------------------------------------------------------\\n\\n ### Further random downsampling\\n\\n # Note: This ensures that the downsampled cloud does not grow with the\\n # input data and instead is of the specified sample_size or smaller.\\n\\n if cloud_ddds.shape[0] > sample_size:\\n cloud_ddds = random_subsample(cloud_ddds, sample_size)\\n\\n #--------------------------------------------------------------------------\\n\\n ### Return result\\n return cloud_ddds\",\n \"def crescent_data(num_data=200, seed=default_seed):\\r\\n np.random.seed(seed=seed)\\r\\n sqrt2 = np.sqrt(2)\\r\\n # Rotation matrix\\r\\n R = np.array([[sqrt2 / 2, -sqrt2 / 2], [sqrt2 / 2, sqrt2 / 2]])\\r\\n # Scaling matrices\\r\\n scales = []\\r\\n scales.append(np.array([[3, 0], [0, 1]]))\\r\\n scales.append(np.array([[3, 0], [0, 1]]))\\r\\n scales.append([[1, 0], [0, 3]])\\r\\n scales.append([[1, 0], [0, 3]])\\r\\n means = []\\r\\n means.append(np.array([4, 4]))\\r\\n means.append(np.array([0, 4]))\\r\\n means.append(np.array([-4, -4]))\\r\\n means.append(np.array([0, -4]))\\r\\n\\r\\n Xparts = []\\r\\n num_data_part = []\\r\\n num_data_total = 0\\r\\n for i in range(0, 4):\\r\\n num_data_part.append(round(((i + 1) * num_data) / 4.))\\r\\n num_data_part[i] -= num_data_total\\r\\n part = np.random.normal(size=(num_data_part[i], 2))\\r\\n part = np.dot(np.dot(part, scales[i]), R) + means[i]\\r\\n Xparts.append(part)\\r\\n num_data_total += num_data_part[i]\\r\\n X = np.vstack((Xparts[0], Xparts[1], Xparts[2], Xparts[3]))\\r\\n\\r\\n Y = np.vstack((np.ones((num_data_part[0] + num_data_part[1], 1)), -np.ones((num_data_part[2] + num_data_part[3], 1))))\\r\\n return {'X':X, 'Y':Y, 'info': \\\"Two separate classes of data formed approximately in the shape of two crescents.\\\"}\",\n \"def generatePoints(centre: Point, radius: float, numPoints: int, jitterRatio: float = 0) -> List[Point]:\\n def jitter() -> float:\\n diamiter = radius * math.pi * 2\\n jitterSize = jitterRatio * diamiter / numPoints\\n return random.random() * 2 * jitterSize - jitterSize\\n\\n points: List[Point] = []\\n angle_segment = math.pi * 2 / numPoints\\n angle = 0\\n\\n while angle < math.pi * 2:\\n point = (centre[0] + radius * math.cos(angle) + jitter(),\\n centre[1] + radius * math.sin(angle) + jitter())\\n points.append(point)\\n angle += angle_segment\\n\\n return points\",\n \"def test_with_predefined_dist(self, seed):\\n dim = Dimension(\\\"yolo\\\", dists.norm, 0.9)\\n samples = dim.sample(seed=seed)\\n assert len(samples) == 1\\n assert dists.norm.rvs(0.9) == samples[0]\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def generate_triangle(seed, num_points=200):\\n points = {\\n 0: 750,\\n 750: 0,\\n 1500: 751\\n }\\n random.seed(seed)\\n while len(points) < num_points:\\n y_coord = (random.randrange(500) or 1) + 200\\n x_coord = random.randrange(round(y_coord*4/3)) + round((500 - y_coord)*(3/4)) + 400\\n if (not points.get(x_coord)) and (x_coord != 750):\\n points[x_coord] = y_coord\\n\\n os.makedirs(os.path.join(DATA_DIR, seed), exist_ok=True)\\n filepath = os.path.join(DATA_DIR, '{}/triangle.node'.format(seed))\\n\\n # creates the input nodes used by triangle to create delauney graph\\n with open(filepath, 'w') as node_file:\\n header = \\\"{} 2 0 0\\\\n\\\".format(len(points))\\n node_file.write(header)\\n i = 1\\n for x_coord, y_coord in points.items():\\n node_file.write(\\\" {} {} {}\\\\n\\\".format(i, x_coord, y_coord))\\n i += 1\\n node_file.close()\\n\\n call(['triangle', '-e', filepath])\",\n \"def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\\n\\n # generate clusters of blobs\\n generated_points_x, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_x,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n generated_points_y, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_y,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n # remove decimals\\n generated_points_x = generated_points_x.astype(\\\"int\\\")\\n generated_points_y = generated_points_y.astype(\\\"int\\\")\\n\\n ind_delete = np.logical_or.reduce(\\n (\\n generated_points_x < 0,\\n generated_points_y < 0,\\n generated_points_x > xsize - 1,\\n generated_points_y > ysize - 1,\\n ),\\n )\\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n\\n return generated_points_x, generated_points_y\",\n \"def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\\n rand.seed(seed)\\n cluster_boundaries = np.cumsum(cluster_sizes)\\n print(\\\"#seed:\\\", seed)\\n print(\\\"#deletion factor:\\\", del_factor)\\n print(\\\"#insertion factor:\\\", ins_factor)\\n optimal_costs = np.array([0])\\n for c in range(0, len(cluster_sizes)-1):\\n n_c = cluster_sizes[c+1]\\n offset_c = cluster_boundaries[c]\\n edges_c = generate_edges(n_c, offset_c)\\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\\n print(\\\"#optimal costs:\\\", optimal_costs)\",\n \"def generate_curves(self, seed=None):\\n num_context = tf.random_uniform(\\n shape=[], minval=self._min_num_context, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\\n\\n # If we are testing we want to have more targets and have them evenly\\n # distributed in order to plot the function.\\n if self._testing:\\n num_target = self._num_pts_per_inst #self._x_data.get_shape().as_list()[0]\\n num_total_points = num_target\\n # During training the number of target points and their x-positions are\\n # selected at random\\n else:\\n num_target = tf.random_uniform(shape=(), minval=0, \\n maxval=self._max_num_context - num_context,\\n dtype=tf.int32, seed=seed)\\n num_total_points = num_context + num_target\\n\\n # idx for x vals in target\\n idxs = []\\n # which instance to get y data from\\n insts = []\\n for i in range(self._batch_size):\\n idxs.append( tf.random_shuffle(tf.range(self._num_pts_per_inst), seed=seed) )\\n insts.append( tf.random_uniform(shape=[], minval=0, maxval=self._num_inst-1, dtype=tf.int32, seed=seed) )\\n \\n idxs = tf.stack(idxs)\\n insts = tf.stack(insts)\\n \\n # batchsize x numtotalpoints x size (xsize or ysize)\\n x_values = tf.stack([tf.expand_dims(tf.gather(self._x_uniq, idxs[tf.cast(i,tf.int32)][:tf.cast(num_total_points,tf.int32)]), axis=-1) for i in range(self._batch_size)])\\n y_values = tf.stack([tf.expand_dims(tf.gather(self._y_data[insts[i]*self._num_pts_per_inst:(insts[i]+1)*self._num_pts_per_inst], idxs[i][:num_total_points]), axis=-1) for i in range(self._batch_size)])\\n \\n \\n \\n if self._testing:\\n # Select the targets\\n target_x = x_values\\n target_y = y_values\\n\\n # Select the observations\\n idx_ctxt = tf.random_shuffle(tf.range(num_target), seed=seed)\\n context_x = tf.gather(x_values, idx_ctxt[:num_context], axis=1)\\n context_y = tf.gather(y_values, idx_ctxt[:num_context], axis=1)\\n\\n else:\\n # Select the targets which will consist of the context points as well as\\n # some new target points\\n target_x = x_values[:, :num_target + num_context, :]\\n target_y = y_values[:, :num_target + num_context, :]\\n\\n # Select the observations\\n context_x = x_values[:, :num_context, :]\\n context_y = y_values[:, :num_context, :]\\n \\n context_x = tf.squeeze(context_x,-1)\\n target_x = tf.squeeze(target_x,-1)\\n\\n context_y = tf.squeeze(context_y,-1)\\n target_y= tf.squeeze(target_y,-1)\\n\\n query = ((context_x, context_y), target_x)\\n\\n return NPRegressionDescription(\\n query=query,\\n target_y=target_y,\\n num_total_points=tf.shape(target_x)[1],\\n num_context_points=num_context)\",\n \"def randomize_spaced_out_points(space, separation, n_points):\\n #obj = poisson_disk.pds(space[0], space[1], space[2], separation, n_points)\\n obj = naive_spaced_randomizer.naive_spaced_randomizer(space[0], space[1], space[2], separation, n_points)\\n return obj.randomize_spaced_points()\",\n \"def make_datagens(data_points):\\n data_gen_args = dict(\\n rotation_range=10.,\\n width_shift_range=0.1,\\n height_shift_range=0.1,\\n zoom_range=0.1,\\n )\\n\\n x_datagen = keras.preprocessing.image.ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True,\\n **data_gen_args,\\n )\\n\\n y_datagen = keras.preprocessing.image.ImageDataGenerator(\\n featurewise_center=False,\\n featurewise_std_normalization=False,\\n **data_gen_args,\\n )\\n\\n x_datagen.fit(utils.list_of_images_to_4d_array([dp.x for dp in data_points]))\\n y_datagen.fit(utils.list_of_images_to_4d_array([dp.y for dp in data_points]))\\n\\n return [x_datagen, y_datagen]\",\n \"def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\\n np.random.seed(12345)\\n a, b, c = nvect / np.linalg.norm(nvect)\\n x, y = np.random.rand(npts), np.random.rand(npts)\\n z = (dparam - a * x - b * y) / c\\n if eps > 0:\\n z += np.random.normal(loc=0., scale=eps, size=npts)\\n return np.column_stack((x, y, z))\",\n \"def random_linearly_separable_data(num_points, bounds):\\n\\n points = random_plane_points(num_points, bounds)\\n weights = random_hyperplane(bounds)\\n labels = np.sign(np.dot(np.column_stack([np.ones((num_points, 1)), \\n points]), weights))\\n return (points, labels, weights)\",\n \"def create_data(self, N, d):\\n X_neg = np.random.randn(np.floor(N/2.0), d) + 2*np.ones((1, d))\\n X_pos = np.random.randn(np.ceil(N/2.0), d) - 2*np.ones((1, d))\\n X = np.vstack((X_neg, X_pos))\\n\\n Y_neg = np.zeros((np.floor(N/2.0), 1))\\n Y_pos = np.ones((np.ceil(N/2.0), 1))\\n Y = np.vstack((Y_neg, Y_pos))\\n\\n return Data(X, Y)\",\n \"def generate_curves(self, seed=None):\\n num_context = tf.random_uniform(\\n shape=[], minval=3, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\\n\\n # If we are testing we want to have more targets and have them evenly\\n # distributed in order to plot the function.\\n if self._testing:\\n num_target = self._x_data.get_shape().as_list()[0]\\n num_total_points = num_target\\n # During training the number of target points and their x-positions are\\n # selected at random\\n else:\\n num_target = tf.random_uniform(shape=(), minval=0, \\n maxval=self._max_num_context - num_context,\\n dtype=tf.int32, seed=seed)\\n num_total_points = num_context + num_target\\n\\n # idx for x vals in target\\n idxs = []\\n # which instance to get y data from\\n insts = []\\n for i in range(self._batch_size):\\n idxs.append( tf.random_shuffle(tf.range(self._num_pts_per_inst), seed=seed) )\\n insts.append( tf.random_uniform(shape=[], minval=0, maxval=self._num_inst-1, dtype=tf.int32, seed=seed) )\\n \\n idxs = tf.stack(idxs)\\n insts = tf.stack(insts)\\n \\n # batchsize x numtotalpoints x size (xsize or ysize)\\n x_values = tf.stack([tf.expand_dims(tf.gather(self._x_uniq, idxs[tf.cast(i,tf.int32)][:tf.cast(num_total_points,tf.int32)]), axis=-1) for i in range(self._batch_size)])\\n y_values = tf.stack([tf.expand_dims(tf.gather(self._y_data[insts[i]*self._num_pts_per_inst:(insts[i]+1)*self._num_pts_per_inst], idxs[i][:num_total_points]), axis=-1) for i in range(self._batch_size)])\\n \\n \\n \\n if self._testing:\\n # Select the targets\\n target_x = x_values\\n target_y = y_values\\n\\n # Select the observations\\n idx_ctxt = tf.random_shuffle(tf.range(num_target), seed=seed)\\n context_x = tf.gather(x_values, idx_ctxt[:num_context], axis=1)\\n context_y = tf.gather(y_values, idx_ctxt[:num_context], axis=1)\\n\\n else:\\n # Select the targets which will consist of the context points as well as\\n # some new target points\\n target_x = x_values[:, :num_target + num_context, :]\\n target_y = y_values[:, :num_target + num_context, :]\\n\\n # Select the observations\\n context_x = x_values[:, :num_context, :]\\n context_y = y_values[:, :num_context, :]\\n \\n context_x = tf.squeeze(context_x,-1)\\n target_x = tf.squeeze(target_x,-1)\\n\\n query = ((context_x, context_y), target_x)\\n\\n return NPRegressionDescription(\\n query=query,\\n target_y=target_y,\\n num_total_points=tf.shape(target_x)[1],\\n num_context_points=num_context)\",\n \"def generate_data(nb_samples):\\n inputs = torch.empty(nb_samples, 2).uniform_(0, 1)\\n center = Tensor([0.5, 0.5]).view(1, -1)\\n distances = torch.norm((inputs - center).abs(), 2, 1)\\n labels = (distances < 1 / math.sqrt(2 * math.pi)).type(LongTensor)\\n return inputs.t(), labels\",\n \"def random():\\n # Define lattice spacing as a multiple of the particle radius\\n # using the formula a = 4 r/sqrt(3). Systems which are ordered\\n # are probably mostly filled, so use a distribution which goes from\\n # zero to one, but leaving 90% of them within 80% of the\\n # maximum bcc packing. Lattice distortion values are empirically\\n # useful between 0.01 and 0.7. Use an exponential distribution\\n # in this range 'cuz its easy.\\n radius = 10**np.random.uniform(1.3, 4)\\n d_factor = 10**np.random.uniform(-2, -0.7) # sigma_d in 0.01-0.7\\n dnn_fraction = np.random.beta(a=10, b=1)\\n dnn = radius*4/np.sqrt(3)/dnn_fraction\\n pars = dict(\\n #sld=1, sld_solvent=0, scale=1, background=1e-32,\\n dnn=dnn,\\n d_factor=d_factor,\\n radius=radius,\\n )\\n return pars\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def _random_points_3d(self, number_of_seeds, min_z, max_z):\\n # Sanity check. We can't get more seeds than what's available in the bounds\\n assert number_of_seeds <= self.cell_count\\n\\n found = {}\\n while len(found) < number_of_seeds:\\n pt = Point2D(random.randint(self._lower_left.x, self._upper_right.x),\\n random.randint(self._lower_left.y, self._upper_right.y))\\n if pt not in found: # make sure unique\\n found[pt] = random.randint(min_z, max_z)\\n return [Point3D(pt.x, pt.y, z) for pt, z in found.items()]\",\n \"def _getDistribution(\\n self, targetPoints, minDudes, maxDudes, groupCount, maxLevel):\\n\\n maxIterations = 10+maxDudes*2\\n\\n def _getTotals(groups):\\n totalPoints = 0\\n totalDudes = 0\\n for group in groups:\\n for entry in group:\\n dudes = entry[1]\\n totalPoints += entry[0]*dudes\\n totalDudes += dudes\\n return totalPoints, totalDudes\\n\\n groups = []\\n for g in range(groupCount):\\n groups.append([])\\n\\n types = [1]\\n if maxLevel > 1:\\n types.append(2)\\n if maxLevel > 2:\\n types.append(3)\\n if maxLevel > 3:\\n types.append(4)\\n\\n for iteration in range(maxIterations):\\n # see how much we're off our target by\\n totalPoints, totalDudes = _getTotals(groups)\\n diff = targetPoints - totalPoints\\n dudesDiff = maxDudes - totalDudes\\n # add an entry if one will fit\\n value = types[random.randrange(len(types))]\\n group = groups[random.randrange(len(groups))]\\n if len(group) == 0:\\n maxCount = random.randint(1, 6)\\n else:\\n maxCount = 2*random.randint(1, 3)\\n maxCount = min(maxCount, dudesDiff)\\n count = min(maxCount, diff/value)\\n if count > 0:\\n group.append((value, count))\\n totalPoints += value*count\\n totalDudes += count\\n diff = targetPoints - totalPoints\\n\\n totalPoints, totalDudes = _getTotals(groups)\\n full = (totalPoints >= targetPoints)\\n\\n if full:\\n # every so often, delete a random entry just to\\n # shake up our distribution\\n if random.random() < 0.2 and iteration != maxIterations-1:\\n entryCount = 0\\n for group in groups:\\n for entry in group:\\n entryCount += 1\\n if entryCount > 1:\\n delEntry = random.randrange(entryCount)\\n entryCount = 0\\n for group in groups:\\n for entry in group:\\n if entryCount == delEntry:\\n group.remove(entry)\\n break\\n entryCount += 1\\n\\n # if we don't have enough dudes, kill the group with\\n # the biggest point value\\n elif totalDudes < minDudes and iteration != maxIterations-1:\\n biggestValue = 9999\\n biggestEntry = None\\n for group in groups:\\n for entry in group:\\n if entry[0] > biggestValue or biggestEntry is None:\\n biggestValue = entry[0]\\n biggestEntry = entry\\n biggestEntryGroup = group\\n if biggestEntry is not None:\\n biggestEntryGroup.remove(biggestEntry)\\n\\n # if we've got too many dudes, kill the group with the\\n # smallest point value\\n elif totalDudes > maxDudes and iteration != maxIterations-1:\\n smallestValue = 9999\\n smallestEntry = None\\n for group in groups:\\n for entry in group:\\n if entry[0] < smallestValue or smallestEntry is None:\\n smallestValue = entry[0]\\n smallestEntry = entry\\n smallestEntryGroup = group\\n smallestEntryGroup.remove(smallestEntry)\\n\\n # close enough.. we're done.\\n else:\\n if diff == 0:\\n break\\n\\n return groups\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def create_data(self):\\n\\n print (f'Using {self.n_s} simulations for the training data to estimate cov')\\n print (f'Using {self.n_p} simulations for the upper/lower training data')\\n print (f'Number of splits, to increase number simulations: {self.n_train}')\\n print (f'Adding noise to the derivative: {np.invert(self.noiseless_deriv)}')\\n\\n # Number of upper and lower simulations\\n n_p = int(self.n_s * self.derivative_fraction)\\n\\n # set a seed to surpress the sample variance (EVEN FOR CENTRAL SIMULATIONS)\\n seed = np.random.randint(1e6) \\n # We should double-check to see if the sample variance if being surpressed\\n\\n # Perturb lower \\n np.random.seed(seed)\\n t_m = self.generate_data(np.array([self.theta_fid for i in \\n range(self.n_train * self.n_p)])\\n ,train = -self.delta_theta, flatten = self.flatten\\n ,noiseless_deriv = self.noiseless_deriv) \\n # Perturb higher \\n np.random.seed(seed)\\n t_p = self.generate_data(np.array([theta_fid for i in \\n range(self.n_train * self.n_p)])\\n ,train = self.delta_theta, flatten = self.flatten\\n , noiseless_deriv = self.noiseless_deriv)\\n\\n # Central\\n np.random.seed(seed)\\n t = self.generate_data(np.array([self.theta_fid for i in \\n range(self.n_train * self.n_s)])\\n ,train = None, flatten = self.flatten)\\n\\n\\n # derivative data\\n t_d = (t_p - t_m) / (2. * self.delta_theta)\\n\\n # Save in a dict that the network takes\\n data = {\\\"data\\\": t, \\\"data_d\\\": t_d}\\n # for plotting purposes we save the upper/lower separately as well\\n data[\\\"x_m\\\"], data[\\\"x_p\\\"] = t_m, t_p \\n\\n\\n # Repeat the same story to generate test data\\n print ('\\\\n')\\n print (f'Using {self.n_s} simulations for the test data to estimate cov')\\n print (f'Using {self.n_p_val} simulations for the upper/lower test data')\\n print (f'Number of splits, to increase number simulations: {self.n_train_val}')\\n print (f'Adding noise to the derivative: {np.invert(self.noiseless_deriv)}')\\n print ('\\\\n')\\n\\n seed = np.random.randint(1e6)\\n # Perturb lower \\n np.random.seed(seed)\\n tt_m = self.generate_data(np.array([self.theta_fid for i in \\n range(self.n_train * self.n_p)])\\n , train = -self.delta_theta, flatten = self.flatten\\n , noiseless_deriv = self.noiseless_deriv)\\n # Perturb higher \\n np.random.seed(seed)\\n tt_p = self.generate_data(np.array([self.theta_fid for i in \\n range(self.n_train * self.n_p)])\\n , train = self.delta_theta, flatten = self.flatten\\n , noiseless_deriv = self.noiseless_deriv)\\n # Central sim\\n np.random.seed(seed)\\n tt = self.generate_data(np.array([self.theta_fid for i in \\n range(self.n_train * self.n_s)])\\n , train = None, flatten = self.flatten)\\n \\n # np.random.seed()\\n \\n # derivative data\\n tt_d = (tt_p - tt_m) / (2. * self.delta_theta)\\n\\n data[\\\"validation_data\\\"] = tt \\n data[\\\"validation_data_d\\\"] = tt_d\\n\\n # for plotting purposes we save the upper/lower separately\\n data[\\\"x_m_test\\\"], data[\\\"x_p_test\\\"] = tt_m, tt_p \\n\\n return data\",\n \"def diamond(N, D, rng):\\n samples = rng.randn(N, D)\\n norm = np.sum(np.abs(samples), axis=1)\\n return samples/norm[:,None]\",\n \"def createFromData(data, r):\\n m = DensityEstimator()\\n #print \\\"Creating denisty estimator from data...\\\"\\n\\n m.mixture_dimensions = data.shape[1]\\n m.dataset_size = data.shape[0]\\n m.threshold = r\\n \\n # Normalisation of the data set\\n m.normalisation_vector_min = np.array([0.0]*data.shape[1])\\n m.normalisation_vector_max = np.array([0.0]*data.shape[1])\\n for i in range(0, data.shape[1]):\\n #data[:, i] -= min(data[:, i])\\n #print i, \\\": \\\", max(data[:, i])\\n m.normalisation_vector_min[i] = min(data[:, i]) \\n m.normalisation_vector_max[i] = max(data[:, i])\\n if m.normalisation_vector_min[i] == m.normalisation_vector_max[i]:\\n m.normalisation_vector_min[i] = 0.0\\n \\n #data[:, i] -= m.normalisation_vector_min[i]\\n #data[:, i] /= (m.normalisation_vector_max[i] - m.normalisation_vector_min[i])\\n #data[:, i] /= (m.normalisation_vector_max[i] )\\n #print m.normalisation_vector[i]\\n #return\\n \\n # Split into clusters / kernels\\n t=set()\\n d=set(range(0,data.shape[0]))\\n def get_random():\\n sample = random.randint( 0, data.shape[0]-1 )\\n while sample in t:\\n sample = random.randint( 0, data.shape[0] - 1 )\\n t.add(sample)\\n return sample\\n \\n sets=[]\\n while len(t)<data.shape[0]:\\n i = get_random()\\n sets.append(set([i]))\\n #print \\\"Cluster at\\\", i, \\n for j in d-t:\\n if np.sqrt(sum((data[i,:]-data[j,:])**2)) < r:\\n sets[-1].add(j)\\n t.add(j)\\n #print \\\"members = \\\", len (sets[-1])\\n new_set = list()\\n for i in sets[-1]:\\n new_set.append(data[i, :])\\n sets[-1] = np.array(new_set)\\n \\n #print \\\"Cluster count=\\\",len(sets)\\n #for i in sets:\\n #print 'sets: ',i\\n \\n # Turn each cluster into a Gaussian kernel\\n\\n # Any set that has less than 3 members merge with nearests\\n minimum_members = 2 #data.shape[1] # mixture dimensions to avoid singular covariance.\\n #print sets\\n #for i in sets:\\n #if len(i) < minimum_members:\\n #print \\\"Small set \\\"\\n #for pt in i:\\n #close = [None, 1e100000]\\n #for j in sets:\\n ##print i\\n #print j\\n #if (i == j).all():\\n #print \\\"same\\\"\\n #continue\\n #print \\\"diff\\\"\\n #if len(j) < minimum_members:\\n #continue # err, bad, should allow possibile join smalls\\n #mu = np.sum(i, 0) / (1.0 * i.shape[0])\\n #dist = sum([(m - p)**2 for m, p in zip(mu, pt)])\\n #print dist\\n #if dist < close[1]:\\n #close[1] = dist\\n #close[0] = j\\n #close[0].add(pt)\\n \\n \\n m.kernels = []\\n for i in sets:\\n if len(i) >= minimum_members:\\n m.kernels.append(GaussKernel(i, i.shape[0]/(1. * data.shape[0])))\\n else:\\n print \\\"LOST SOME\\\"\\n #else:\\n #print \\\"->Warning: dropping data point as it lies alone, singular\\\"\\n #print \\\"ok.\\\"\\n return m\",\n \"def createDist(N):\\n return np.random.normal(loc=1000.,scale=5.,size=np.random.poisson(lam=N))\",\n \"def generateModelData(params, standoffDistance, nSamples):\\n initialEnergy, eLoss, e2, e3, sigma = params\\n \\n data_x=np.random.uniform(low=0.0, high=distance_cellLength, size=nSamples)\\n meanEnergy = initialEnergy + eLoss*data_x + \\\\\\n e2*np.power(data_x,2) + e3 * np.power(data_x,3)\\n data_ed= np.random.normal(loc=meanEnergy, scale=sigma)\\n data_en = getDDneutronEnergy(data_ed)\\n \\n neutronDistance = standoffDistance + (distance_cellLength - data_x) + \\\\\\n distance_zeroDegLength/2\\n neutronTOF = getTOF(mass_neutron, data_en, neutronDistance)\\n effectiveDenergy = (initialEnergy + data_ed)/2\\n deuteronTOF = getTOF( mass_deuteron, effectiveDenergy, data_x )\\n data_tof = neutronTOF + deuteronTOF\\n \\n data = np.column_stack((data_x,data_ed,data_en,data_tof))\\n return data\",\n \"def deng_random(seeds):\\n\\n x = seeds[0]\\n y = seeds[1]\\n\\n while 0<1:\\n temp = x\\n x = (x + y) % 1.0\\n y = temp\\n yield x\",\n \"def build_data(seed):\\n rs = np.random.RandomState(seed)\\n\\n def y(x):\\n \\\"\\\"\\\" y(x) = 1 + 0.3 * x_1 - 0.6 * x_2^2 - 0.2 * x_3^3 + 0.5 x_4^4 \\\"\\\"\\\"\\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4\\n\\n xtrain = rs.rand(10000, 4)\\n xtest = rs.rand(1000, 4)\\n ytrain = y(xtrain) + rs.rand(10000) / 10\\n ytest = y(xtest) + rs.rand(1000) / 10\\n return xtrain, xtest, ytrain, ytest\",\n \"def generate(self, n, d):\\n\\n self.n = n\\n self.d = d\\n self.X = np.random.rand(n, d)\\n self.Y = np.random.choice([0, 1], size=n)\",\n \"def sample_deltas(self, number):\\n return (torch.randn(number, 1) + self.delta_mean) * self.delta_std\",\n \"def generate_points(self):\\n for x in range(self.num_sides):\\n for y in range(self.num_sides):\\n for z in range(self.num_sides):\\n col_name = y + 4\\n top_num = 0\\n if 1 < z < 4:\\n top_name = 'b'\\n else:\\n top_name = 'd'\\n if z == 3 or z == 1:\\n top_num += 4\\n top_num += x\\n\\n top_name += str(top_num)\\n\\n k = Node(x*self.length-self.center, y*self.length -\\n self.center, z*self.length-self.center, top_name, col_name)\\n self.c_layers[y].append(k)\\n self.points.append(k)\",\n \"def perturb_points(points,\\n z_vals,\\n ray_directions,\\n device):\\n distance_between_points = z_vals[:, :, 1:2, :] - z_vals[:, :, 0:1, :] # (n, num_rays, 1, 1)\\n offset = (torch.rand(z_vals.shape, device=device) - 0.5) \\\\\\n * distance_between_points # [-0.5, 0.5] * d, (n, num_rays, n_samples, 1)\\n z_vals = z_vals + offset\\n\\n points = points + \\\\\\n offset * ray_directions.unsqueeze(2) # (n, num_rays, n_samples, 3)\\n return points, z_vals\",\n \"def generate_random_DC_MT():\\n # Specify DC moment tensor to rotate:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n # And rotate DC moment tensor by random 3D angle:\\n random_DC_MT = rot_mt_by_theta_phi(DC_MT_to_rot, theta, phi)\\n random_DC_six_MT = get_six_MT_from_full_MT_array(random_DC_MT)\\n # And normallise so that moment tensor magnitude = 1:\\n random_DC_six_MT_normalised = random_DC_six_MT/((np.sum(random_DC_six_MT**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n random_DC_six_MT_normalised = np.reshape(random_DC_six_MT_normalised, (6, 1))\\n return random_DC_six_MT_normalised\",\n \"def Generate_Random( self ):\\n print( 'Generating Random coordinates' )\\n stands = self.Data.Stand.keys()\\n stands.sort()\\n for s in stands:\\n trees = self.Data.Stand[s].Tree.keys()\\n trees.sort()\\n for t in trees:\\n self.Data.Stand[s].Tree[t].X = random.uniform( 0, 208.71 )\\n self.Data.Stand[s].Tree[t].Y = random.uniform( 0, 208.71 )\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def gen_data(min_coord, max_coord, size):\\r\\n data = np.random.randint(min_coord, max_coord, size)\\r\\n return data\",\n \"def derandomize(self, xs, noises):\\n raise NotImplementedError\",\n \"def initialization(n, D):\\n\\n samples = []\\n while len(samples) < n:\\n # X = np.random.randint(0, D.shape[1], 10*n)\\n # Y = np.random.randint(0, D.shape[0], 10*n)\\n X = np.random.uniform(0, D.shape[1], 10*n)\\n Y = np.random.uniform(0, D.shape[0], 10*n)\\n P = np.random.uniform(0, 1, 10*n)\\n index = 0\\n while index < len(X) and len(samples) < n:\\n x, y = X[index], Y[index]\\n x_, y_ = int(np.floor(x)), int(np.floor(y))\\n if P[index] < D[y_, x_]:\\n samples.append([x, y])\\n index += 1\\n return np.array(samples)\",\n \"def Gen_directed_diff(D, dt, vs, sigmaDM, Ns, beta_set=None, withlocerr=True):\\n traces = []\\n for v, n, sig in zip(vs, Ns, sigmaDM):\\n if beta_set is None:\\n beta = np.random.uniform(0, 2 * np.pi)\\n else:\\n beta = beta_set\\n dx, dy = v * dt * np.cos(beta), v * dt * np.sin(beta)\\n\\n xsteps = np.random.normal(0, np.sqrt(2 * D * dt), size=n) + dx\\n ysteps = np.random.normal(0, np.sqrt(2 * D * dt), size=n) + dy\\n\\n x, y = (\\n np.concatenate([[0], np.cumsum(xsteps)]),\\n np.concatenate([[0], np.cumsum(ysteps)]),\\n )\\n if withlocerr:\\n x_noisy, y_noisy = (\\n x + np.random.normal(0, sig, size=x.shape),\\n y + np.random.normal(0, sig, size=y.shape),\\n )\\n traces.append(np.array([x_noisy, y_noisy]).T)\\n else:\\n traces.append(np.array([x, y]).T)\\n return traces\",\n \"def sample_rademacher(shape, dtype, seed_pair):\\n rand_uniform = tf.random.stateless_uniform(shape=shape, seed=seed_pair)\\n return tf.cast(tf.sign(rand_uniform - 0.5), dtype)\",\n \"def generate_data(self):\\n\\n # cfg.d_sour_num = 20 # number of source domains\\n self.d_sour_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_sour_num)]\\n self.d_sour_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_sour_num)]\\n # cfg.d_targ_num = 1 # number of target domain\\n self.d_targ_a = [np.random.uniform(0.1, 5.0) for _ in range(cfg.d_targ_num)]\\n self.d_targ_b = [np.random.uniform(0, np.pi) for _ in range(cfg.d_targ_num)]\\n\\n\\n # cfg.train_num = 100 # number of training point in each domain\\n self.train_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.train_num)], dtype=np.float32).reshape(-1,1)\\n self.train_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.train_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.train_num, 1)\\n\\n # cfg.val_num = 100\\n self.val_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.val_num)], dtype=np.float32).reshape(-1,1)\\n self.val_y = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.val_x] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.val_num, 1)\\n\\n # cfg.support_num = 10\\n self.support_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.support_num)], dtype=np.float32).reshape(-1,1)\\n self.support_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.support_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.support_num, 1)\\n\\n # cfg.test_num = 100\\n self.test_x = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y = np.array([[self.d_targ_a[j] * np.sin(i + self.d_targ_b[j]) for i in self.test_x] for j in range(cfg.d_targ_num)], dtype=np.float32).reshape(cfg.d_targ_num, cfg.test_num, 1)\\n\\n self.test_x_old = np.array([np.random.uniform(-5.0, 5.0) for _ in range(cfg.test_num)], dtype=np.float32).reshape(-1,1)\\n self.test_y_old = np.array([[self.d_sour_a[j] * np.sin(i + self.d_sour_b[j]) for i in self.test_x_old] for j in range(cfg.d_sour_num)], dtype=np.float32).reshape(cfg.d_sour_num, cfg.test_num, 1)\",\n \"def generateData(N, k):\\n n = float(N) / k\\n X = []\\n for i in range(k):\\n c = (random.uniform(-1, 1), random.uniform(-1, 1))\\n s = random.uniform(0.05, 0.5)\\n x = []\\n while len(x) < n:\\n a, b = np.array([np.random.normal(c[0], s), np.random.normal(c[1], s)])\\n # Continue drawing points from the distribution in the range [-1,1]\\n if abs(a) < 1 and abs(b) < 1:\\n x.append([a, b])\\n X.extend(x)\\n X = np.array(X)[:N]\\n # Write list to file for later use\\n f = open('./dataset_N' + str(N) + '_K' + str(k) + '.txt', 'w')\\n for x in X:\\n f.write(str(x[0]) + \\\" \\\" + str(x[1]) + '\\\\n')\\n\\n f.close();\\n\\n return X\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def randomdir(N=1):\\n\\t#r = p1.sampler(rmax)\\n\\tphi = random.random(size=N) * 2 * pi\\n\\t#theta = arccos(random.random()#\\n\\tcostheta = random.random(size=N) * 2 - 1\\n\\t#sintheta = sqrt(1-costheta**2)\\n\\treturn phi, arccos(costheta)\",\n \"def run_gradient_descent(seed=0):\\n random.seed(seed)\\n colors = [color for color in matplotlib.colors.cnames]\\n\\n def random_point():\\n return (2 * random.random() - 1, 2 * random.random() - 1)\\n\\n def df(x_i):\\n \\\"\\\"\\\"this is the gradient of x^2 + y^2\\\"\\\"\\\"\\n return [2 * x_ij for x_ij in x_i]\\n\\n for color in random.sample(colors, 50):\\n path = take(10, gradient_descent(df, random_point()))\\n for i, (x, y) in enumerate(path):\\n plt.plot(x, y, color=color, marker='*', markersize=20-2*i)\\n\\n plt.show()\",\n \"def create_dataset(name, grid=None, samples=1000, seed=0):\\n if grid == None:\\n np.random.seed(seed)\\n points = 1 - 2 * np.random.rand(samples, 2)\\n else:\\n x = np.linspace(-1, 1, grid)\\n points = np.array(list(product(x, x)))\\n creator = globals()[f\\\"_{name}\\\"]\\n\\n x, y = creator(points)\\n return x, y\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def random(cls, d=2, borns=[-1, 1], **kwargs):\\n p1 = Point.random(d, borns)\\n p2 = Point.random(d, borns)\\n return cls(*[p1, p2], **kwargs)\",\n \"def generate_points(num_points):\\n for i in xrange(0, num_points):\\n pass\",\n \"def random_projection_cosine_split(data, indices, rng_state):\\n dim = data.shape[1]\\n\\n # Select two random points, set the hyperplane between them\\n left_index = tau_rand_int(rng_state) % indices.shape[0]\\n right_index = tau_rand_int(rng_state) % indices.shape[0]\\n right_index += left_index == right_index\\n right_index = right_index % indices.shape[0]\\n left = indices[left_index]\\n right = indices[right_index]\\n\\n left_norm = norm(data[left])\\n right_norm = norm(data[right])\\n \\n if left_norm == 0.0:\\n left_norm = 1.0\\n \\n if right_norm == 0.0:\\n right_norm = 1.0\\n\\n # Compute the normal vector to the hyperplane (the vector between\\n # the two points)\\n hyperplane_vector = np.empty(dim, dtype=np.float32)\\n\\n for d in range(dim):\\n hyperplane_vector[d] = ((data[left, d] / left_norm) -\\n (data[right, d] / right_norm))\\n\\n hyperplane_norm = norm(hyperplane_vector)\\n if hyperplane_norm == 0.0:\\n hyperplane_norm = 1.0\\n \\n for d in range(dim):\\n hyperplane_vector[d] = hyperplane_vector[d] / hyperplane_norm\\n\\n # For each point compute the margin (project into normal vector)\\n # If we are on lower side of the hyperplane put in one pile, otherwise\\n # put it in the other pile (if we hit hyperplane on the nose, flip a coin)\\n n_left = 0\\n n_right = 0\\n side = np.empty(indices.shape[0], np.int8)\\n for i in range(indices.shape[0]):\\n margin = 0.0\\n for d in range(dim):\\n margin += hyperplane_vector[d] * data[indices[i], d]\\n\\n if margin == 0:\\n side[i] = tau_rand_int(rng_state) % 2\\n if side[i] == 0:\\n n_left += 1\\n else:\\n n_right += 1\\n elif margin > 0:\\n side[i] = 0\\n n_left += 1\\n else:\\n side[i] = 1\\n n_right += 1\\n\\n # Now that we have the counts allocate arrays\\n indices_left = np.empty(n_left, dtype=np.int64)\\n indices_right = np.empty(n_right, dtype=np.int64)\\n\\n # Populate the arrays with indices according to which side they fell on\\n n_left = 0\\n n_right = 0\\n for i in range(side.shape[0]):\\n if side[i] == 0:\\n indices_left[n_left] = indices[i]\\n n_left += 1\\n else:\\n indices_right[n_right] = indices[i]\\n n_right += 1\\n\\n return indices_left, indices_right\",\n \"def generate_data(func, points, seed=0):\\n np.random.seed(seed)\\n\\n data = []\\n for segment in points:\\n x = np.linspace(*segment[\\\"xlim\\\"], num=segment[\\\"n_points\\\"])\\n distribution = func(x)\\n # Generate observations\\n y = distribution.rvs()\\n df = pd.DataFrame({\\\"x\\\": x, \\\"y\\\": y})\\n data.append(df)\\n\\n return pd.concat(data, ignore_index=True)\",\n \"def distance_dmc(distances, Ks, points):\\n doors = []\\n for d in distances:\\n dmc = []\\n for k in Ks:\\n print \\\"==========================\\\", k, \\\"==========================\\\"\\n clusters = create_clusters(25, k)\\n\\n kmeans(points, clusters)\\n # print \\\"Finished creating kmeans algorithm\\\"\\n\\n create_backbone_network(GRAPH, clusters, d)\\n # print \\\"Finished creating backbone network\\\"\\n\\n find_all_shortest_paths(clusters, SP_TABLE, GRAPH)\\n # print \\\"Finished finding all shortest paths\\\"\\n\\n for clst in clusters:\\n clst.inter_cost = inter_cost(clst)\\n clst.intra_cost = intra_cost(points, clst)\\n clst.dm_cost = door_matt_cost(clusters, clst, SP_TABLE)\\n\\n ret = total_cost(clusters)\\n dmc.append(ret[2])\\n doors.append(sum(dmc))\\n draw_door_matts(map(lambda d: float(format(d, \\\".4g\\\")), distances), doors)\",\n \"def sample(self, d):\\n dist = rnd.uniform(0,self.length)\\n w = rnd.normal(0,self.width)\\n d.pos = np.dot(rotmat(self.angle), [dist, w]) + self.pos\\n d.ownpos = self.pos\",\n \"def make_pnts(start_point, end_point, path, cellsize):\\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\\n \\n #Only do sampling at DEM with >3m resolution \\n if cellsize[0] >= 5:\\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\\n return pnts\",\n \"def generate_normal_data(avg_strike, avg_dip, n=10, noise_std=5, porp=2):\\n opp_strike = avg_strike + 180\\n if opp_strike > 360: \\n opp_strike -= 360\\n strike = avg_strike * np.ones(n)\\n strike[n//porp:] = opp_strike\\n dip = avg_dip * np.ones(n)\\n \\n # Add noise\\n strike += noise_std * np.random.randn(n)\\n dip += noise_std * np.random.randn(n)\\n\\n # Filter out things out of a reasonable range\\n strike[dip > 90] -= 180\\n dip[dip > 90] = 180 - dip[dip>90]\\n\\n strike[dip < 0] -= 180\\n dip[dip < 0] *= -1\\n\\n strike[strike < 0] += 360\\n strike[strike > 360] -= 360\\n \\n\\n normal = geometric_functions.plane2normal(strike, dip)\\n slip = geometric_functions.normal_slip(*normal)\\n\\n return strike, dip, normal, slip\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def _generate_data(self,\\n batch_size: int = 1,\\n num_keypoints: int = 5,\\n norm_item: str = 'box_size') -> tuple:\\n data_batch = []\\n data_samples = []\\n\\n for i in range(batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % batch_size, 0] = False\\n gt_instances[norm_item] = np.random.random((1, 1)) * 20 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n data_batch.append(data)\\n data_samples.append(data_sample)\\n\\n return data_batch, data_samples\",\n \"def generate_data(self, s=0):\\n np.random.seed(s)\\n \\n L_b = np.linalg.cholesky(self.cov_b)\\n L_t = np.linalg.cholesky(self.cov_t)\\n \\n self.x_benchmark = np.dot(L_b,(np.random.randn(self.n_points,2) + self.mean_b).T).T\\n self.x_trial = np.dot(L_t,(np.random.randn(self.n_points,2) + self.mean_t).T).T\",\n \"def generate_parameters(self, cluster_center, std_dev, num_tasks):\\n return np.random.normal(cluster_center, std_dev, num_tasks)\",\n \"def create_panel_of_normals(paths, N, name):\\n dfs = [ pd.read_table(paths[0]) ]\\n for i, path in enumerate(paths[1:]):\\n df_to_concat = pd.read_table(path)\\n dfs.append(df_to_concat)\\n df = pd.concat(dfs, axis=0)\\n # Shuffle samples to pick from all batches\\n df = df.sample(frac=1).reset_index(drop=True)\\n normals = df[df.sample_type==\\\"Normal\\\"][:N]['sample_id']\\n if N==-1: print (\\\"Creating panel of %d normals\\\" %normals.shape[0])\\n else: print (\\\"Creating panel of %d normals\\\" %N)\\n \\n # Compile data\\n data = pd.concat([pd.DataFrame(index=normals.index, columns=['membership:sample_set_id'], data=name), \\\\\\n normals], axis=1)\\n\\n return data\",\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 generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def __generate_spawn_points(self):\\n while True:\\n p1x = random.randint(0, self.width - 1)\\n p1y = random.randint(0, self.height - 1)\\n p2x, p2y = self.__mirror(p1x, p1y)\\n d_sq = (p1x - p2x)**2 + (p1y - p2y)**2\\n if d_sq >= (self.width / 2)**2:\\n break\\n return (p1x, p1y), (p2x, p2y)\",\n \"def generate_scatter(dm):\\n # This section places something on the surface every few units -- good for testing out the get_height method\\n scatter_offset = 128\\n for x in range((map_center[0] - map_size[0] // 2) + scatter_offset, (map_center[0] + map_size[0] // 2), scatter_offset):\\n for y in range((map_center[1] - map_size[1] // 2) + scatter_offset, (map_center[1] + map_size[1] // 2),\\n scatter_offset):\\n\\n slope_angle = math.degrees(dm.get_slope(dm.get_relative_position((x,y))))\\n h = ground.get_height((x, y))\\n\\n if water_height - 64 < h < water_height - 32 and random.randrange(20) == 0:\\n # This spot is in shallow water, so spawn a boat. (spawn it slightly higher than water level, so that it can float)\\n base.PropPhysics(m, origin=Origin(x, y, water_height + 8),\\n angles=Origin(0, random.randrange(360), 0),\\n model=\\\"models/props_canal/boat001{0}.mdl\\\".format((\\\"a\\\", \\\"b\\\")[random.randrange(2)]))\\n elif water_height + 128 < h and random.randrange(15) == 0 and slope_angle < 30:\\n # We have a flat area somewhat away from the shore, so we can put a tree here.\\n base.PropStatic(m, origin=Origin(x, y, h - 3),\\n model=\\\"models/props_foliage/tree_deciduous_0{0}a.mdl\\\".format(random.randrange(3) + 1),\\n angles=Origin(0, random.randrange(360), 0), skin=1)\",\n \"def rand_raster(center, step_size, num_points, random):\\n xscan = []\\n yscan = []\\n \\n xcenter = center[0] # first element of center array\\n ycenter = center[1] # second element of center array\\n \\n scan_size = int(np.sqrt(num_points)) # This assumes a square scan area\\n \\n xrange = np.arange(xcenter - ((scan_size - 1) * step_size) / 2, xcenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n yrange = np.arange(ycenter - ((scan_size - 1) * step_size) / 2, ycenter + ((scan_size - 1) * step_size) / 2 + step_size, step_size)\\n \\n # Creates two arrays xscan and yscan\\n for step, ystep in enumerate(yrange):\\n xscan.append(xrange[::(-1)**step])\\n yscan.append(np.ones_like(xrange) * ystep)\\n \\n xscan = np.concatenate(xscan)\\n yscan = np.concatenate(yscan)\\n \\n # Combine the two arrays into a list of vectors\\n raster = []\\n \\n for i in range(0, len(xscan)):\\n scan_element = []\\n \\n scan_element.append(xscan[i])\\n scan_element.append(yscan[i])\\n raster.append(scan_element)\\n \\n return raster\",\n \"def generate(\\n seeds=10,\\n param_num_nodes=7,\\n mode='train',\\n param_dim=10,\\n param_sel=100,\\n param_mu=10,\\n param_br=0.05,\\n param_activity_wt=None,\\n A=None,\\n sp_to_id=None,\\n min_coord=None,\\n max_coord=None,\\n org_pts=None,\\n ):\\n global dim, sel, mu, br, activity_wt, tree_lc, tree_rc, num_nodes\\n\\n dim=param_dim\\n sel=param_sel\\n mu=param_mu\\n br=param_br\\n activity_wt=param_activity_wt\\n num_nodes = param_num_nodes\\n\\n sp_root = 0\\n tree = None\\n\\n if mode == 'train':\\n tree, tree_lc, tree_rc = generate_tree(sp_root, num_nodes)\\n if param_activity_wt is None:\\n # weights for the linear activity function\\n num_wts = int(((dim * (dim + 1))/2) + 1)\\n activity_wt = np.random.normal(0, 1, num_wts)\\n\\n if org_pts is None:\\n org_pts = []\\n # simulate data points\\n # format: exampleID, species, values\\n # region, species, coord1, coord2, ...., activity_value\\n\\n for i in tqdm(range(int(seeds))):\\n pt_id = i\\n\\n # pick a random point of d-dimension\\n rand_pt = np.random.uniform(min_coord, max_coord, dim)\\n curr_pt = np.append([pt_id, sp_root], rand_pt)\\n curr_activity = get_activity(modify_pt(rand_pt), activity_wt)\\n # print('curr_pt:', curr_pt, 'curr_activity:', curr_activity); exit(0)\\n org_pts.append(np.append(curr_pt, curr_activity))\\n\\n generated_points = []\\n full_org_pts = []\\n\\n if mode == 'train':\\n pool = Pool(16)\\n sample_bag = pool.map(generate_bag, org_pts)\\n for item in sample_bag:\\n for val in item:\\n val = list(val)\\n full_org_pts.append(val)\\n generated_points.append(val[:2]+modify_pt(val[2:-1])+[val[-1]])\\n else:\\n for val in org_pts:\\n val = list(val)\\n generated_points.append(val[:2]+modify_pt(val[2:-1])+[val[-1]])\\n\\n return generated_points, activity_wt, org_pts, full_org_pts, tree\",\n \"def plane_generator():\\n\\n planarRadius = np.sqrt(N / (np.pi * pointDensity)) # <-- convert pointDensity into radius\\n planarThreshold = planarRadius * np.sqrt(thresholdFrac)\\n\\n # distance function (law of cosines)\\n def dist(rTheta1, rTheta2): # rThetai is a coordinate tuple: (r, theta)\\n a, b = rTheta1[0], rTheta2[0]\\n theta1, theta2 = rTheta1[1], rTheta2[1]\\n return np.sqrt(a ** 2 + b ** 2 - 2 * a * b * np.cos(theta1 - theta2)) # <-- law of cosines\\n\\n # computes the adjacency matrices\\n data_plane = []\\n for r in range(num_graphs):\\n\\n # generates dictionary of positions for each node: node_pos = {node_i: (radius, theta)}\\n node_pos = {}\\n for i in range(N):\\n rnd_angle = np.random.random() * 2 * np.pi\\n rnd_radii = np.random.random() * planarRadius\\n node_pos.update({i: (rnd_radii, rnd_angle)})\\n\\n Adj_Matrix = np.zeros((N, N))\\n for i in range(N):\\n for j in range(N):\\n ij_dist = dist(node_pos[i], node_pos[j])\\n if ij_dist < planarThreshold:\\n Adj_Matrix[i, j] = 1 # nodes that are connected are assigned a 1 in the matrix\\n\\n data_plane.append(Adj_Matrix)\\n\\n return data_plane\",\n \"def generate_test():\\n o = []\\n pos = [384, 288]\\n note_group_size = GAN_PARAMS[\\\"note_group_size\\\"]\\n generate_set(begin=3 * note_group_size, start_pos=pos,\\n length_multiplier=dist_multiplier, group_id=3, plot_map=True)\",\n \"def DeviatoricGridRandom(magnitudes=[1.], npts=100000):\\n\\n v = random(-1./3., 1./3., npts)\\n w = np.zeros(npts)\\n kappa = random(0., 360, npts)\\n sigma = random(-90., 90., npts)\\n h = random(0., 1., npts)\\n rho = list(map(to_rho, asarray(magnitudes)))\\n\\n v = np.tile(v, len(magnitudes))\\n w = np.tile(w, len(magnitudes))\\n kappa = np.tile(kappa, len(magnitudes))\\n sigma = np.tile(sigma, len(magnitudes))\\n h = np.tile(h, len(magnitudes))\\n rho = np.repeat(rho, npts)\\n\\n return UnstructuredGrid(\\n dims=('rho', 'v', 'w', 'kappa', 'sigma', 'h'),\\n coords=(rho, v, w, kappa, sigma, h),\\n callback=to_mt)\",\n \"def generate_k(data_set, k):\\n centers = []\\n dimensions = len(data_set[0])\\n min_max = defaultdict(int)\\n\\n for point in data_set:\\n for i in range(dimensions):\\n val = point[i]\\n min_key = 'min_{0}d'.format(i)\\n max_key = 'max_{0}d'.format(i)\\n if min_key not in min_max or val < min_max[min_key]:\\n min_max[min_key] = val\\n if max_key not in min_max or val > min_max[max_key]:\\n min_max[max_key] = val\\n\\n for _k in range(k):\\n rand_point = []\\n for i in range(dimensions):\\n min_val = min_max['min_{0}d'.format(i)]\\n max_val = min_max['max_{0}d'.format(i)]\\n \\n rand_point.append(uniform(min_val, max_val))\\n centers.append(rand_point)\\n return centers\",\n \"def __init__(self):\\n # start x position\\n self.x = random.randrange(size_x)\\n # start y position\\n self.y = - random.randrange(100)\\n # drift x (amount of change each loop along the x axis)\\n self.dx = random.randrange(3) - random.randrange(6)\\n # drift y (amount of change each loop along the y axis)\\n self.dy = random.randrange(1, 20) + random.randrange(4)\\n # the size of the circular snowflake\\n self.size = random.randrange(1, 4)\\n # the colour of the snowflake (from sludgy grey to snowy white)\\n c = random.randrange(200, 256)\\n self.color = [c, c, c]\",\n \"def test_d_3():\\n rs = 20\\n d = 3\\n np.random.seed(rs)\\n number_rotations = 3\\n\\n theta_1 = np.random.uniform(0, 2 * math.pi)\\n rotation_1 = np.identity(d)\\n pos_1 = np.random.randint(0, d - 1)\\n pos_2 = np.random.randint(pos_1 + 1, d)\\n rotation_1[pos_1, pos_1] = math.cos(theta_1)\\n rotation_1[pos_1, pos_2] = - math.sin(theta_1)\\n rotation_1[pos_2, pos_1] = math.sin(theta_1)\\n rotation_1[pos_2, pos_2] = math.cos(theta_1)\\n\\n theta_2 = np.random.uniform(0, 2 * math.pi)\\n rotation_2 = np.identity(d)\\n pos_3 = np.random.randint(0, d - 1)\\n pos_4 = np.random.randint(pos_3 + 1, d)\\n rotation_2[pos_3, pos_3] = math.cos(theta_2)\\n rotation_2[pos_3, pos_4] = - math.sin(theta_2)\\n rotation_2[pos_4, pos_3] = math.sin(theta_2)\\n rotation_2[pos_4, pos_4] = math.cos(theta_2)\\n\\n theta_3 = np.random.uniform(0, 2 * math.pi)\\n rotation_3 = np.identity(d)\\n pos_5 = np.random.randint(0, d - 1)\\n pos_6 = np.random.randint(pos_5 + 1, d)\\n rotation_3[pos_5, pos_5] = math.cos(theta_3)\\n rotation_3[pos_5, pos_6] = - math.sin(theta_3)\\n rotation_3[pos_6, pos_5] = math.sin(theta_3)\\n rotation_3[pos_6, pos_6] = math.cos(theta_3)\\n\\n final_rotation = rotation_1 @ rotation_2 @ rotation_3\\n np.random.seed(rs)\\n rotation_function = (mt_obj.calculate_rotation_matrix\\n (d, number_rotations))\\n assert(np.all(final_rotation == rotation_function))\",\n \"def create_distortions(self, x1, y1, x2, y2):\\n if not self.distortions:\\n return [x1, y1, x2, y2]\\n\\n angle_perpendicular = self.angle + 90.0\\n points = len(self.distortions)\\n\\n segments = [x1, y1]\\n\\n # For 3 points, we have: x = (3x1 + x2) / 4, (2x1 + 2x2) / 4, (x1 + 3x2) / 4\\n for i, distortion in enumerate(self.distortions):\\n xpos = ((points - i) * x1 + (i + 1) * x2) / (points + 1)\\n ypos = ((points - i) * y1 + (i + 1) * y2) / (points + 1)\\n segments.extend(move_point(xpos, ypos, angle_perpendicular, self.distance * distortion))\\n\\n segments.extend([x2, y2])\\n\\n return segments\",\n \"def make_travel_dataset():\\n util.make_dataset_dmoz(\\n n_items=600,\\n seed=0,\\n category_parent='Top/Recreation/Travel',\\n rawdir=os.environ['DMOZ_TRAVEL_RAW'],\\n webdir=os.environ['DMOZ_TRAVEL_WEB'],\\n )\",\n \"def __create_sample_data__(npts = 20):\\n\\t#data function\\n\\tdef wavy(x, y):\\n\\t\\treturn np.sin(0.2*np.pi*x)*np.cos(0.4*np.pi*y)\\n\\t\\n\\t#make grid\\n\\txs = np.linspace(0, 2*20, 2*npts + 1)\\n\\tys = np.linspace(0, 20, npts + 1)\\n\\t(xgrid, ygrid) = np.meshgrid(xs, ys)\\n\\tzgrid = wavy(xgrid, ygrid)\\n\\t\\n\\treturn (xgrid, ygrid, zgrid)\",\n \"def generate_random_data(size, x_min=X_MIN, x_max=X_MAX, y_min=Y_MIN, y_max=Y_MAX):\\n result = []\\n for _i in range(size):\\n result.append((randint(x_min, x_max), randint(y_min, y_max)))\\n\\n return result\",\n \"def generate_self_collision_dataset(start, num_joints, num_points):\\n total_number_points = 0\\n\\n # import environment\\n empty_environment()\\n\\n # initialize validity check\\n space = initialize_space()\\n ss = og.SimpleSetup(space)\\n state_validity_checker = MoveitOMPLStateValidityChecker(ss.getSpaceInformation())\\n\\n # header for the dataset\\n limb_name = 'right'\\n header_written = False\\n header = get_joint_names(limb_name) + [SELF_COLLISION_KEY]\\n\\n directory = DIRECTORY % \\\"empty_environment\\\"\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n file_name = os.path.join(directory, get_file_name(limb_name, num_joints, num_points, start))\\n\\n # statistics for tracking generation\\n batch_time = []\\n\\n for i in range(0, int(math.ceil(float(num_points) / BATCH_SIZE))):\\n print(\\\"Elasped time: %s\\\" % (time.time() - start))\\n print(\\\"Start generating data for batch: %s\\\" % (i + 1))\\n batch_start = i * BATCH_SIZE\\n batch_end = batch_start + BATCH_SIZE\\n size = BATCH_SIZE\\n\\n if batch_end >= num_points:\\n # We've come to the last batch\\n size = num_points - batch_start\\n\\n batch_time_start = time.time()\\n\\n samples = generate_configs(size, state_validity_checker, limb_name)\\n\\n with open(file_name, mode='a') as csv_file:\\n # Quote header such that it is easier for reader to parse data\\n writer = csv.DictWriter(csv_file, fieldnames=header, quoting=csv.QUOTE_NONNUMERIC)\\n if not header_written:\\n writer.writeheader()\\n header_written = True\\n writer.writerows(samples)\\n total_number_points += size\\n\\n # Save time to generate batch for later statistics\\n batch_time_end = time.time()\\n batch_time.append(batch_time_end - batch_time_start)\\n\\n # output statistics;\\n end = time.time()\\n total_time = end - start\\n print(\\\"Finished generating self-collision dataset. \\\" +\\n \\\"Total time elapsed: %s; Total number of points: %s\\\" % (total_time, total_number_points))\\n print(\\\"Average time to produce a batch of size %s: %s\\\" % (\\n BATCH_SIZE, reduce(lambda x, y: x + y, batch_time) / len(batch_time)))\\n return file_name\",\n \"def __init__(self, sample_size, neighbours, lengths, offsets, seed=0):\\n self.sample_size = sample_size\\n self.seed, self.seed2 = random_seed.get_seed(seed)\\n self.neighbours = neighbours\\n self.lengths = lengths\\n self.offsets = offsets\\n super(UniformEdgeDataset, self).__init__()\",\n \"def dyn_trajectory(Tinit, delT, n):\\n Titer = Tinit\\n # note that copy is necessary, otherwise delPos is just a view on delT\\n # which causes it to change when delT changes\\n delPos = delT[:2, 2:3].copy() \\n for i in xrange(n):\\n tmp = Titer\\n positer = Titer[:2, 2:3]\\n # Center of rotation is around around positer (TODO: accept it as\\n # paramter)\\n delT[:2, 2:3] = delPos -delT[:2, :2].dot(positer) + positer \\n Titer = delT.dot(Titer)\\n yield tmp\",\n \"def build_toy_dataset(N):\\n y_data = np.random.uniform(-10.5, 10.5, N)\\n r_data = np.random.normal(size=N) # random noise\\n x_data = np.sin(0.75 * y_data) * 7.0 + y_data * 0.5 + r_data * 1.0\\n x_data = x_data.reshape((N, 1))\\n return train_test_split(x_data, y_data, random_state=42)\",\n \"def generate_two_dim_multi_type4(self, num_data):\\n mu_before = np.random.choice(self.num_interval, size=[num_data * 3, 2])\\n r = np.random.exponential(scale=10, size=[num_data * 3])\\n theta = np.random.uniform(low=0, high=2 * math.pi, size=[num_data * 3])\\n\\n mu_after = np.zeros(shape=mu_before.shape, dtype=np.float32)\\n mu_after[:, 0] = mu_before[:, 0] + r * np.cos(theta)\\n mu_after[:, 1] = mu_before[:, 1] + r * np.sin(theta)\\n mu_after = np.around(mu_after).astype(np.int)\\n\\n select_id = np.where((mu_after[:, 0] >= 0) & (mu_after[:, 0] <= self.num_interval) &\\n (mu_after[:, 1] >= 0) & (mu_after[:, 1] <= self.num_interval))[0][:num_data]\\n\\n mu_before, mu_after = mu_before[select_id], mu_after[select_id]\\n vel = np.sqrt(np.sum((mu_after - mu_before) ** 2, axis=1)) * self.interval_length\\n\\n place_pair = {'before': mu_before, 'after': mu_after, 'vel': vel}\\n return place_pair\\n\\n # def generate_two_dim_test(self, num_data, velocity, num_step):\\n # mu_seq = np.zeros(shape=[num_data, 2], dtype=np.int32)\\n # vel_pool = np.where((self.velocity[:, 0] >= -1) & (self.velocity[:, 1] >= -1))\\n # vel_idx = np.random.choice(vel_pool[0], size=num_data)\\n # vel = np.zeros(shape=[num_data, 2], dtype=np.float32)\\n #\\n # mu = [6, 6]\\n #\\n # for i in range(num_data):\\n # mu_seq[i] = mu\\n # v_idx = vel_idx[i]\\n # v = self.velocity[v_idx]\\n # mu = mu + v\\n # vel[i] = v * self.interval_length\\n #\\n # vel_idx.astype(np.int32)\\n #\\n # place_data = {'place_seq': mu_seq, 'vel_idx': vel_idx, 'vel': vel}\\n # return place_data\",\n \"def generate_base_points(num_points, domain_size, density_map=None,\\n reflect=True):\\n\\n def _try_points(num_points, prob):\\n prob = np.atleast_3d(prob)\\n prob = np.array(prob)/np.amax(prob) # Ensure prob is normalized\\n base_pts = []\\n N = 0\\n while N < num_points:\\n pt = np.random.rand(3) # Generate a point\\n # Test whether to keep it or not\\n [indx, indy, indz] = np.floor(pt*np.shape(prob)).astype(int)\\n if np.random.rand(1) <= prob[indx][indy][indz]:\\n base_pts.append(pt)\\n N += 1\\n base_pts = np.array(base_pts)\\n return base_pts\\n\\n if len(domain_size) == 1: # Spherical\\n domain_size = np.array(domain_size)\\n r = domain_size[0]\\n if density_map is None:\\n # Make an image of a sphere filled with ones and use _try_points\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, 20] = 0\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to spherical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0.5]).T\\n r = 2*np.sqrt(X**2 + Y**2 + Z**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n phi = 2*np.arctan(np.sqrt(X**2 + Y**2)/Z)\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, phi] = [r[inds], theta[inds], phi[inds]]\\n # Reflect base points across perimeter\\n if reflect:\\n r, theta, phi = reflect_base_points(np.vstack((r, theta, phi)),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_spherical(r, theta, phi)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 2: # Cylindrical or Disk\\n domain_size = np.array(domain_size)\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n density_map[20, 20, :] = 0\\n if domain_size[1] == 0: # Disk\\n density_map = density_map[:, :, 0]\\n density_map = spim.distance_transform_edt(density_map) < 20\\n base_pts = _try_points(num_points, density_map)\\n # Convert to cylindrical coordinates\\n X, Y, Z = np.array(base_pts - [0.5, 0.5, 0]).T # Center on z-axis\\n r = 2*np.sqrt(X**2 + Y**2)*domain_size[0]\\n theta = 2*np.arctan(Y/X)\\n z = Z*domain_size[1]\\n # Trim points outside the domain (from improper prob images)\\n inds = r <= domain_size[0]\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n inds = ~((z > domain_size[1]) + (z < 0))\\n [r, theta, z] = [r[inds], theta[inds], z[inds]]\\n if reflect:\\n r, theta, z = reflect_base_points(np.vstack([r, theta, z]),\\n domain_size)\\n # Convert to Cartesean coordinates\\n X, Y, Z = from_cylindrical(r, theta, z)\\n base_pts = np.vstack([X, Y, Z]).T\\n\\n elif len(domain_size) == 3: # Cube or square\\n if density_map is None:\\n density_map = np.ones([41, 41, 41])\\n if domain_size[2] == 0:\\n density_map = density_map[:, :, 0]\\n base_pts = _try_points(num_points, density_map)\\n base_pts = base_pts*domain_size\\n if reflect:\\n base_pts = reflect_base_points(base_pts, domain_size)\\n\\n return base_pts\",\n \"def get_germes_regular(img, nb_points):\\n print(\\\"============================\\\")\\n print(\\\"Seed selection\\\")\\n\\n germes = []\\n dist_between_pts = img.shape[0] * img.shape[1] // nb_points\\n\\n for i in range(nb_points):\\n # on ajoute une petite variation aleatoire\\n diff_x = random.randint(-5, 5)\\n diff_y = random.randint(-5, 5)\\n\\n n = dist_between_pts * i\\n\\n sx = n % img.shape[0] + diff_x\\n sy = n // img.shape[0] + diff_y\\n\\n sx = max(min(sx, img.shape[0]-1), 0)\\n sy = max(min(sy, img.shape[1]-1), 0)\\n\\n germes.append((sx, sy))\\n\\n return germes\",\n \"def generate_random_surface_points() -> List[SurfacePoint]:\\n surface_points: List[SurfacePoint] = []\\n for _ in range(42):\\n surface_point = SurfacePoint(\\n idx=uuid.uuid4().hex,\\n x=_gen_random_number(),\\n y=_gen_random_number(),\\n z=_gen_random_number(),\\n x_uc_dist=DistUcEnum.uniform,\\n x_uc=_gen_random_number(),\\n y_uc_dist=DistUcEnum.uniform,\\n y_uc=_gen_random_number(),\\n z_uc_dist=DistUcEnum.uniform,\\n z_uc=_gen_random_number(),\\n smooth=0.01,\\n formation=\\\"Formation_0\\\",\\n )\\n surface_points.append(surface_point)\\n return surface_points\",\n \"def new_density(points):\\n inshape = points.shape\\n points = points.view(-1, 3)\\n out = []\\n for p in points:\\n if torch.all(p > 0.5) or torch.all(p < -0.5):\\n out.append(torch.tensor([[1.0]]))\\n else:\\n out.append(torch.tensor([[0.0]]))\\n return torch.cat(out).view(*inshape[:-1], 1).to(device)\",\n \"def random_pred_test_data(size: int, seed: int = 4321):\\n y_pred = tf.random.stateless_normal((size,), seed=(seed, 0))\\n y_test = tf.random.stateless_normal((size,), seed=(seed, 1))\\n return y_pred, y_test\",\n \"def __randomize_data(self):\\n times = map(lambda (t, _): t, self.data)\\n coords = map(lambda (_, c): c, self.data)\\n return zip(times, map(DataGen.__randomize_coord, coords))\",\n \"def generate_edges(self):\\n for i, n in enumerate(self.points):\\n for i1, p in enumerate(self.points[i+1:]):\\n d = 0\\n differences = 0\\n for x in range(3):\\n d += math.fabs(n.xyz[x] - p.xyz[x])\\n if math.fabs(n.xyz[x] - p.xyz[x]) != 0:\\n differences += 1\\n\\n if differences > 1:\\n continue\\n\\n if d == -1 * self.side_length or d == self.side_length:\\n self.edges.append([i, i1 + i + 1])\",\n \"def generate_curves(self, seed = None):\\n num_context = tf.random_uniform(\\n shape=[], minval=3, maxval=self._max_num_context, dtype=tf.int32, seed=seed)\\n\\n # If we are testing we want to have more targets and have them evenly\\n # distributed in order to plot the function.\\n if self._testing:\\n num_target = 400\\n num_total_points = num_target\\n x_values = tf.tile(\\n tf.expand_dims(tf.range(-2., 2., 1. / 100, dtype=tf.float32), axis=0),\\n [self._batch_size, 1])\\n x_values = tf.expand_dims(x_values, axis=-1)\\n # During training the number of target points and their x-positions are\\n # selected at random\\n else:\\n num_target = tf.random_uniform(shape=(), minval=0, \\n maxval=self._max_num_context - num_context,\\n dtype=tf.int32, seed=seed)\\n num_total_points = num_context + num_target\\n x_values = tf.random_uniform(\\n [self._batch_size, num_total_points, self._x_size], -2, 2, seed=seed)\\n\\n # Set kernel parameters\\n # Either choose a set of random parameters for the mini-batch\\n if self._random_kernel_parameters:\\n l1 = tf.random_uniform([self._batch_size, self._y_size,\\n self._x_size], 0.1, self._l1_scale)\\n sigma_f = tf.random_uniform([self._batch_size, self._y_size],\\n 0.1, self._sigma_scale)\\n # Or use the same fixed parameters for all mini-batches\\n else:\\n l1 = tf.ones(shape=[self._batch_size, self._y_size,\\n self._x_size]) * self._l1_scale\\n sigma_f = tf.ones(shape=[self._batch_size,\\n self._y_size]) * self._sigma_scale\\n\\n # Pass the x_values through the Gaussian kernel\\n # [batch_size, y_size, num_total_points, num_total_points]\\n kernel = self._gaussian_kernel(x_values, l1, sigma_f)\\n\\n # Calculate Cholesky, using double precision for better stability:\\n cholesky = tf.cast(tf.cholesky(tf.cast(kernel, tf.float64)), tf.float32)\\n\\n # Sample a curve\\n # [batch_size, y_size, num_total_points, 1]\\n y_values = tf.matmul(\\n cholesky,\\n tf.random_normal([self._batch_size, self._y_size, num_total_points, 1], seed=seed))\\n\\n # [batch_size, num_total_points, y_size]\\n y_values = tf.transpose(tf.squeeze(y_values, 3), [0, 2, 1])\\n\\n if self._testing:\\n # Select the targets\\n target_x = x_values\\n target_y = y_values\\n\\n # Select the observations\\n idx = tf.random_shuffle(tf.range(num_target), seed=seed)\\n context_x = tf.gather(x_values, idx[:num_context], axis=1)\\n context_y = tf.gather(y_values, idx[:num_context], axis=1)\\n\\n else:\\n # Select the targets which will consist of the context points as well as\\n # some new target points\\n target_x = x_values[:, :num_target + num_context, :]\\n target_y = y_values[:, :num_target + num_context, :]\\n\\n # Select the observations\\n context_x = x_values[:, :num_context, :]\\n context_y = y_values[:, :num_context, :]\\n\\n query = ((context_x, context_y), target_x)\\n\\n return NPRegressionDescription(\\n query=query,\\n target_y=target_y,\\n num_total_points=tf.shape(target_x)[1],\\n num_context_points=num_context)\",\n \"def makePLDS(T, x_0, f, g, Dx, Dy):\\n\\tX = np.zeros((T, Dx))\\n\\tY = np.zeros((T, Dy))\\n\\n\\tX[0] = x_0\\n\\tY[0] = g.sample(x_0)\\n\\tfor t in range(1,T):\\n\\t\\tX[t] = f.sample(X[t-1])\\n\\t\\tY[t] = g.sample(X[t])\\n\\treturn X, Y\",\n \"def sample_dirichlet(alpha, batch_size=100):\\n return np.random.dirichlet(alpha, batch_size)\",\n \"def make_tutorial_data(n: int) -> pd.DataFrame:\\n np.random.seed(1111)\\n\\n dataset = pd.DataFrame({\\n \\\"id\\\": list(map(lambda x: \\\"id%d\\\" % x, np.random.randint(0, 100, n))),\\n \\\"date\\\": np.random.choice(pd.date_range(\\\"2015-01-01\\\", periods=100), n),\\n \\\"feature1\\\": np.random.gamma(20, size=n),\\n \\\"feature2\\\": np.random.normal(40, size=n),\\n \\\"feature3\\\": np.random.choice([\\\"a\\\", \\\"b\\\", \\\"c\\\"], size=n)})\\n\\n dataset[\\\"target\\\"] = (dataset[\\\"feature1\\\"]\\n + dataset[\\\"feature2\\\"]\\n + dataset[\\\"feature3\\\"].apply(lambda x: 0 if x == \\\"a\\\" else 30 if x == \\\"b\\\" else 10)\\n + np.random.normal(0, 5, size=n))\\n\\n # insert some NANs\\n dataset.loc[np.random.randint(0, n, 100), \\\"feature1\\\"] = nan\\n dataset.loc[np.random.randint(0, n, 100), \\\"feature3\\\"] = nan\\n\\n return dataset\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6200814","0.60125065","0.6008298","0.58964354","0.5652766","0.5627772","0.56074226","0.55708045","0.55676484","0.54426163","0.54371774","0.5432757","0.54286873","0.5412957","0.53979236","0.53931975","0.53886104","0.5388139","0.5384613","0.53822875","0.538003","0.537996","0.53692085","0.5352782","0.5328673","0.5315658","0.5310943","0.5294078","0.527585","0.52743083","0.5267582","0.52666193","0.5264785","0.5249556","0.524868","0.5238711","0.5212051","0.5202894","0.51840705","0.5180144","0.5168334","0.51664394","0.51581615","0.5155","0.51531357","0.5151069","0.51361203","0.51330143","0.5111258","0.5108587","0.5100846","0.5085126","0.5083076","0.5074212","0.50725096","0.50718343","0.50715625","0.50715405","0.50498474","0.50443876","0.5042128","0.50419766","0.50377226","0.5032402","0.500106","0.5000986","0.4994315","0.49895778","0.49829447","0.49789876","0.496213","0.49612692","0.49439037","0.49430224","0.4932421","0.49315587","0.49291646","0.49274653","0.49190694","0.4917742","0.49104652","0.49082512","0.49058732","0.4902902","0.48990515","0.48989394","0.48926327","0.4889846","0.48896077","0.4886047","0.48840708","0.48797515","0.4874886","0.4873773","0.48728272","0.48726544","0.48628247","0.4859751","0.48562828","0.48546115"],"string":"[\n \"0.6200814\",\n \"0.60125065\",\n \"0.6008298\",\n \"0.58964354\",\n \"0.5652766\",\n \"0.5627772\",\n \"0.56074226\",\n \"0.55708045\",\n \"0.55676484\",\n \"0.54426163\",\n \"0.54371774\",\n \"0.5432757\",\n \"0.54286873\",\n \"0.5412957\",\n \"0.53979236\",\n \"0.53931975\",\n \"0.53886104\",\n \"0.5388139\",\n \"0.5384613\",\n \"0.53822875\",\n \"0.538003\",\n \"0.537996\",\n \"0.53692085\",\n \"0.5352782\",\n \"0.5328673\",\n \"0.5315658\",\n \"0.5310943\",\n \"0.5294078\",\n \"0.527585\",\n \"0.52743083\",\n \"0.5267582\",\n \"0.52666193\",\n \"0.5264785\",\n \"0.5249556\",\n \"0.524868\",\n \"0.5238711\",\n \"0.5212051\",\n \"0.5202894\",\n \"0.51840705\",\n \"0.5180144\",\n \"0.5168334\",\n \"0.51664394\",\n \"0.51581615\",\n \"0.5155\",\n \"0.51531357\",\n \"0.5151069\",\n \"0.51361203\",\n \"0.51330143\",\n \"0.5111258\",\n \"0.5108587\",\n \"0.5100846\",\n \"0.5085126\",\n \"0.5083076\",\n \"0.5074212\",\n \"0.50725096\",\n \"0.50718343\",\n \"0.50715625\",\n \"0.50715405\",\n \"0.50498474\",\n \"0.50443876\",\n \"0.5042128\",\n \"0.50419766\",\n \"0.50377226\",\n \"0.5032402\",\n \"0.500106\",\n \"0.5000986\",\n \"0.4994315\",\n \"0.49895778\",\n \"0.49829447\",\n \"0.49789876\",\n \"0.496213\",\n \"0.49612692\",\n \"0.49439037\",\n \"0.49430224\",\n \"0.4932421\",\n \"0.49315587\",\n \"0.49291646\",\n \"0.49274653\",\n \"0.49190694\",\n \"0.4917742\",\n \"0.49104652\",\n \"0.49082512\",\n \"0.49058732\",\n \"0.4902902\",\n \"0.48990515\",\n \"0.48989394\",\n \"0.48926327\",\n \"0.4889846\",\n \"0.48896077\",\n \"0.4886047\",\n \"0.48840708\",\n \"0.48797515\",\n \"0.4874886\",\n \"0.4873773\",\n \"0.48728272\",\n \"0.48726544\",\n \"0.48628247\",\n \"0.4859751\",\n \"0.48562828\",\n \"0.48546115\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70498824"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9484,"cells":{"query":{"kind":"string","value":"Create 4 cluster centers. Create gaussians centered at (1,1), (1,1), (1,1) and (1,1). Each has standard covariance."},"document":{"kind":"string","value":"def gen_4_normal():\n return [mn(mean=np.array([1.0, 1.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([1.0, -1.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([-1.0, -1.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([-1.0, 1.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))]"},"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 generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def plot_centroid_means_and_covars_3d(instance_centroids,\n nominal_locations,\n canonical_centroid=None,\n canonical_normal=None,\n cov_mat_allStructures=None,\n radii_allStructures=None,\n ellipsoid_matrix_allStructures=None,\n colors=None,\n show_canonical_centroid=True,\n xlim=(0,400),\n ylim=(0,400),\n zlim=(0,400),\n xlabel='x',\n ylabel='y',\n zlabel='z',\n title='Centroid means and covariances'):\n\n # Load ellipsoid: three radius and axes.\n if radii_allStructures is not None and ellipsoid_matrix_allStructures is not None:\n pass\n elif cov_mat_allStructures is not None:\n radii_allStructures, ellipsoid_matrix_allStructures = compute_ellipsoid_from_covar(cov_mat_allStructures)\n else:\n _, radii_allStructures, ellipsoid_matrix_allStructures = compute_covar_from_instance_centroids(instance_centroids)\n\n # Plot in 3D.\n\n from mpl_toolkits.mplot3d import Axes3D\n from metadata import name_unsided_to_color, convert_to_original_name\n\n fig = plt.figure(figsize=(20, 20))\n ax = fig.add_subplot(111, projection='3d')\n\n if colors is None:\n colors = {name_s: (0,0,1) for name_s in instance_centroids}\n\n for name_s, centroids in instance_centroids.iteritems():\n # if name_s == '7N_L' or name_s == '7N_R':\n\n if canonical_centroid is None:\n centroids2 = np.array(centroids)\n else:\n centroids2 = np.array(centroids) + canonical_centroid\n\n ax.scatter(centroids2[:,0], centroids2[:,1], centroids2[:,2],\n marker='o', s=100, alpha=.1, color=colors[name_s])\n\n if canonical_centroid is None:\n c = nominal_locations[name_s]\n else:\n c = nominal_locations[name_s] + canonical_centroid\n\n ax.scatter(c[0], c[1], c[2],\n color=colors[name_s], marker='*', s=100)\n\n # Plot uncerntainty ellipsoids\n u = np.linspace(0.0, 2.0 * np.pi, 100)\n v = np.linspace(0.0, np.pi, 100)\n x = radii_allStructures[name_s][0] * np.outer(np.cos(u), np.sin(v))\n y = radii_allStructures[name_s][1] * np.outer(np.sin(u), np.sin(v))\n z = radii_allStructures[name_s][2] * np.outer(np.ones_like(u), np.cos(v))\n for i in range(len(u)):\n for j in range(len(v)):\n [x[i,j],y[i,j],z[i,j]] = np.dot([x[i,j],y[i,j],z[i,j]], ellipsoid_matrix_allStructures[name_s]) + c\n\n # ax.plot_surface(x, y, z, color='b')\n ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2)\n\n if canonical_centroid is not None:\n if show_canonical_centroid:\n ax.scatter(canonical_centroid[0], canonical_centroid[1], canonical_centroid[2],\n color=(0,0,0), marker='^', s=200)\n\n # Plot mid-sagittal plane\n if canonical_normal is not None:\n canonical_midplane_xx, canonical_midplane_yy = np.meshgrid(range(xlim[0], xlim[1], 100), range(ylim[0], ylim[1], 100), indexing='xy')\n canonical_midplane_z = -(canonical_normal[0]*(canonical_midplane_xx-canonical_centroid[0]) + \\\n canonical_normal[1]*(canonical_midplane_yy-canonical_centroid[1]) + \\\n canonical_normal[2]*(-canonical_centroid[2]))/canonical_normal[2]\n ax.plot_surface(canonical_midplane_xx, canonical_midplane_yy, canonical_midplane_z, alpha=.1)\n else:\n sys.stderr.write(\"canonical_centroid not provided. Skip plotting cenonical centroid and mid-sagittal plane.\\n\")\n\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n ax.set_zlabel(zlabel)\n # ax.set_axis_off()\n ax.set_xlim3d([xlim[0], xlim[1]]);\n ax.set_ylim3d([ylim[0], ylim[1]]);\n ax.set_zlim3d([zlim[0], zlim[1]]);\n # ax.view_init(azim = 90 + 20,elev = 0 - 20)\n ax.view_init(azim = 270, elev = 0)\n\n # Hide y-axis (https://stackoverflow.com/questions/12391271/matplotlib-turn-off-z-axis-only-in-3-d-plot)\n ax.w_yaxis.line.set_lw(0.)\n ax.set_yticks([])\n\n ax.set_aspect(1.0)\n ax.set_title(title)\n plt.legend()\n plt.show()","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def init_centers(self, S, labels):\n unique_labels = np.unique(labels)\n centers = None\n\n for label in unique_labels:\n idx = np.squeeze(labels == label)\n cur_S = S[idx, :]\n cur_center = np.mean(cur_S, axis=0)\n if centers is None:\n centers = cur_center\n else:\n centers = np.vstack((centers, cur_center))\n centers = np.asarray(centers, dtype=floatX)\n self.C.set_value(centers)","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def centroids(self):\n return self.mdm_.covmeans_","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def computeCenters3d(self, data):\n\n\n for i in range(self.nPoints):\n print(\"Label of point \", i, \" is \", self.labels[i])\n for j in range(3):\n self.centers[self.labels[i]][j] += data[i][j]\n\n for c in range(self.n):\n for j in range(3):\n self.centers[c][j] /= self.tots[c]","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def initClusters(self):\n if len(self.labelList) != len(self.pointList):\n \traise ValueError(\"Label List and Point List not the same length!\")\n for i in range(len(self.labelList)):\n self.centroids[self.labelList[i]] = self.pointList[i]\n self.pointcounts[self.labelList[i]] = 1","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def mergeCenters(nCenters):\r\n\tpath = os.getcwd()\r\n\tos.chdir('Centers/')\r\n\tcenter = np.zeros((0,128))\t\t#: Populator for centers\r\n\r\n\tfor i in os.listdir(os.getcwd()):\r\n\t Center = open(i,\"rb\")\t\t#: File pointer for centers file\r\n\t center = np.vstack((center, pickle.load(Center)))\t#Populate centers\r\n\t Center.close()\r\n\r\n\tcenter = np.float32(center)\r\n\tcriteria = (cv2.TERM_CRITERIA_MAX_ITER, 10,0.0001)\r\n\t#Checking version of opencv..\r\n\tif __verison__[0] == '3':\r\n\t\tret,label,center=cv2.kmeans(center,int(nCenters),None,criteria,50,cv2.KMEANS_PP_CENTERS)\r\n\telse:\r\n\t\tret,label,center=cv2.kmeans(center,int(nCenters),criteria,50,cv2.KMEANS_PP_CENTERS)\r\n\r\n\tCenterFinal = open(path+'/centerFinal.p',\"wb\")#: File pointer for final centers file\r\n\tpickle.dump(center, CenterFinal)\t#Dump centers to file\r\n\tCenterFinal.close()","def centers(self):\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)","def calculate_centroids(self, data, clusters):\n centroids = []\n for i in range(self.n_clusters):\n mask = clusters == i \n centroids.append(np.mean(data[mask, :], axis = 0)) \n return centroids","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def xcenters(self):\n return self.centers[0]","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def centroid(coords,masses,divider):\n\treturn np.array([np.dot(masses[r].T,coords[r])/np.sum(masses[r]) for r in divider])","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def update(self, clusters):\n centroids = {}\n for cluster, coordinates in clusters.iteritems():\n sumLat = 0\n sumLong = 0\n for coordinate in coordinates:\n sumLat += float(coordinate[0])\n sumLong += float(coordinate[1])\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\n return centroids","def plot(X, clusters, cluster_num):\n centroids = []\n X = np.asarray(X)\n for i in range(0,cluster_num):\n centroids.append(clusters[i].centroid)\n \n np_centroids = np.asarray(centroids)\n \n color = [\"g\", \"r\", \"b\", \"c\", \"m\", \"b\"]\n \n fig = figure()\n ax = fig.gca(projection='3d')\n for i in range(len(X)):\n ax.scatter(X[i][0], X[i][1], X[i][2], c=color)\n \n ax.scatter(np_centroids[:, 0],np_centroids[:, 1],\n np_centroids[:, 2], marker = \"x\", s=150,\n linewidths = 5, zorder = 100, c=color\n )","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def __init__(self,\n n_clusters=0,\n centroids=None,\n data=None,\n labels=[],\n distance='cov',\n threshold=0.38,\n dimension=128,\n update_centroids=True):\n self.n_clusters = n_clusters\n self.threshold = threshold\n self.distance = distance\n self.dimension = dimension\n self.update_centroids = update_centroids\n if centroids is None:\n self.centroids = np.zeros((n_clusters, 1, dimension))\n else:\n self.centroids = np.array(centroids)\n\n # if data is None:\n # self.data = np.zeros((n_clusters, 1, dimension))\n # else:\n # self.data = np.array(data)\n self.labels = np.array(labels, dtype=np.int32)","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\n\n if random_state is not None: np.random.seed(random_state)\n\n n_samples = n_samples//n_cluster\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\n\n for cluster_idx in range(n_cluster):\n # Group indicator\n #group = sp.binom.rvs(p=0.25, n=1, size=N\n n_neg = int(n_samples*(1-pos_ratio))\n n_pos = n_samples-n_neg\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\n\n idx_dependent = n_var - n_dependent\n\n if mean is None:\n basic_mean = 0 #np.random.uniform(size=no_var)\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n else:\n mean0 = mean[cluster_idx][0]\n mean1 = mean[cluster_idx][1]\n \n\n # # Noise are variables with same distribution in majority and minority class\n # if noise_ratio != 0:\n # n_noise = int(noise_ratio*n_var)\n # noise_idx = n_var - n_noise\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\n # size=n_samples).reshape([n_samples,-1])\n \n cov0, cov1 = None, None\n\n X1 = []\n X0 = []\n # Independent variables\n if n_var-n_dependent > 0:\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\n\n # Dependent variables\n if n_dependent>0:\n if cov is None:\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n else:\n cov0 = cov[cluster_idx][0]\n cov1 = cov[cluster_idx][1]\n\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\n cov= cov1, size=n_pos)\n )\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\n cov= cov0, size=n_neg)\n )\n \n X0 = np.hstack([*X0])\n X1 = np.hstack([*X1])\n X_cluster.append(np.vstack([X0, X1]))\n #X = np.hstack([X, X_noise])\n\n mean0_cluster.append(mean0)\n mean1_cluster.append(mean1)\n cov0_cluster.append(cov0)\n cov1_cluster.append(cov1)\n\n if n_cluster == 1:\n X = X_cluster[0]\n y = y_cluster[0]\n else:\n X = np.vstack(X_cluster)\n y = np.hstack(y_cluster)\n\n #return {\"X\":X, \"y\":y,\"mean0\":mean0,\"mean1\":mean1, \"cov0\":cov0, \"cov1\":cov1}\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def compute_covar_from_instance_centroids(instance_centroids):\n\n cov_mat_allStructures = {}\n radii_allStructures = {}\n ellipsoid_matrix_allStructures = {}\n for name_s, centroids in sorted(instance_centroids.items()):\n centroids2 = np.array(centroids)\n cov_mat = np.cov(centroids2.T)\n cov_mat_allStructures[name_s] = cov_mat\n u, s, vt = np.linalg.svd(cov_mat)\n # print name_s, u[:,0], u[:,1], u[:,2],\n radii_allStructures[name_s] = np.sqrt(s)\n ellipsoid_matrix_allStructures[name_s] = vt\n\n return cov_mat_allStructures, radii_allStructures, ellipsoid_matrix_allStructures","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def fit_satellite_centers(image, spotcenters_init, window=20):\n # fit satellite centers\n scs = np.zeros((len(spotcenters_init), 2))\n for idx,xy in enumerate(spotcenters_init):\n subim = pre.subimage(image, xy, window=window)\n popt = snm.image_centroid_gaussian1(subim)\n xcenp = popt[1]\n ycenp = popt[2]\n xcen = xy[0]-round(window/2)+xcenp\n ycen = xy[1]-round(window/2)+ycenp\n scs[idx,:] = xcen, ycen \n \n return scs","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def centers(self):\n def make_centers(x):\n return 0.25 * (x[:-1, :-1] + x[:-1, 1:] + x[1:, :-1] + x[1:, 1:])\n\n polar_centers = make_centers(self.polar_corners)\n azimuthal_centers = make_centers(self.azimuthal_corners)\n\n assert azimuthal_centers.shape == polar_centers.shape\n return polar_centers, azimuthal_centers","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\n self.d = d\n\n # 95% of data lies in a 2*sigma ball around the mean.\n # For unit variance normal, the 2*sigma ball mean the centers\n # should be at distance of 4 in the d dimensional space.\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\n cov = np.eye(d)\n\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\n # print(dist_mean)\n # cov = np.eye(d)\n\n frac = int(1 / pos_fraction)\n\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\n\n self.X = np.vstack((cluster1, cluster2))\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\n\n # Make blobs\n # if True:\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def __get_initial_centroid(self, x_train, seed=None):\n if self.init == \"random\":\n # randomly select n_cluster point from the input dataset\n if seed:\n random.seed(seed)\n return np.asarray(random.choices(x_train, k=self.n_cluster))","def calcCentroid(self):\n size = len(self.vectors)\n # zip all features together\n zipped = zip(*self.vectors)\n # Calculate the mean for each feature/column\n centroid = [math.fsum(column)/size for column in zipped]\n \n return centroid","def centroid(sign, FS):\n\n time = compute_time(sign, FS)\n\n energy, time_energy=signal_energy(sign, time)\n\n total_energy = np.dot(np.array(time_energy),np.array(energy))\n energy_sum = np.sum(energy)\n\n if energy_sum == 0 or total_energy == 0:\n centroid = 0\n else:\n centroid = total_energy / energy_sum\n return centroid","def _init_centroid(self, data):\n\n\t\tcentroids = data[:self._k]\n\t\tx_assignee = data\n\n\t\treturn centroids, x_assignee","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def k_means_cc(self, X_columns, y_column, k, n_features=0):\n try:\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\n \n\n fig = plt.figure(1)\n fig.subplots_adjust(hspace=0.5)\n for x in range(0,centroids.shape[1]):\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\n cmap = 'Set1'\n for c in range(centroids.shape[0]):\n temp_df = labeled_features[labeled_features['clusters'] == c]\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\n ax.set_xlabel(labeled_features.columns[x])\n ax.axis('tight')\n if(x == 0):\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\n plt.annotate(\"Silhouette Coefficient: \"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\n plt.suptitle(\"Scatter Plot of \"+labeled_features.columns[0]+\" against other Features\")\n \n fig2 = plt.figure(2)\n ax2 = fig2.subplots()\n for k in range(centroids.shape[0]):\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\": \"+str(centroids[k]))\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\n plt.xlabel(\"Features\")\n plt.ylabel(\"Location\")\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\"left\" )\n plt.legend(loc=\"upper right\",title='Clusters (Centroids)')\n plt.title(\"Centroid Chart (\"+y_column+\")\")\n plt.tight_layout()\n\n plt.show()\n\n except Exception as e:\n print(e)","def __init__(self, init_centers):\n\n assert len(init_centers.shape) == 2, f\"init_centers should be a KxD matrix. Got: {init_centers.shape}\"\n (self.K, self.D) = init_centers.shape\n assert self.K > 1, f\"There must be at least 2 clusters. Got: {self.K}\"\n\n # Shape: K x D\n self.centers = np.copy(init_centers)","def consolidate(params, centroid_m=(0,0,0), centroid_f=(0,0,0)):\n G = params.reshape((3,4))\n R = G[:3,:3]\n t = - np.dot(R, centroid_m) + G[:3,3] + centroid_f\n return np.vstack([np.c_[R,t], [0,0,0,1]])","def calculate_cluster_center(self, threshold):\n gamma = self.gamma\n self.cluster_center = np.where(gamma >= threshold)[0]","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def get_element_centroids(self):\n if self.centroids is None:\n self.centroids = np.vstack((\n np.mean(self.grid['x'], axis=1),\n np.mean(self.grid['z'], axis=1)\n )).T\n\n return self.centroids","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def __cmeans(self, points, nclusters):\n # load list of points for cluster analysis\n # initialize\n initial_centers = kmeans_plusplus_initializer(points, nclusters, kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE).initialize()\n # create instance of Fuzzy C-Means algorithm\n fcm_instance = fcm(points, initial_centers)\n # run cluster analysis and obtain results\n fcm_instance.process()\n clusters = fcm_instance.get_clusters()\n centers = fcm_instance.get_centers()\n membership = fcm_instance.get_membership()\n return clusters, centers, membership","def atlas_clusters():\n pass","def compute_variance(\n data, cluster_labels, centroids, alpha=10, debug=False, num_class=None\n):\n\n k = len(centroids) if num_class is None else num_class\n phis = torch.zeros(k)\n for c in range(k):\n cluster_points = data[cluster_labels == c]\n c_len = len(cluster_points)\n if c_len == 0:\n phis[c] = -1\n elif c_len == 1:\n phis[c] = 0.05\n else:\n phis[c] = torch.sum(torch.norm(cluster_points - centroids[c], dim=1)) / (\n c_len * np.log(c_len + alpha)\n )\n if phis[c] < 0.05:\n phis[c] = 0.05\n\n if debug:\n print(\"size-phi:\", end=\" \")\n for i in range(k):\n size = (cluster_labels == i).sum().item()\n print(f\"{size}[phi={phis[i].item():.3f}]\", end=\", \")\n print(\"\\n\")\n\n return phis","def initiateCentroid(data_points, centroids, k):\n #Create empty list in list (amount is k)\n AvgCentroids = [[] for i in range(k)]\n\n #For each datapoint in all datapoints\n for dp in data_points:\n dis = []\n #For each centroid in centroids\n for c in range(len(centroids)):\n #Calculate the euclidean distance between those points and append\n #to distance list\n dis.append(calcEuclideanDistance(dp, centroids[c]))\n \n #Get the smallest value of the list and the index\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\n\n #The index of the smallest value is the index where it will be added\n #to the avgCentroids list. So it represents the number of the cluster\n AvgCentroids[idx].append(dp)\n \n return AvgCentroids"],"string":"[\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def plot_centroid_means_and_covars_3d(instance_centroids,\\n nominal_locations,\\n canonical_centroid=None,\\n canonical_normal=None,\\n cov_mat_allStructures=None,\\n radii_allStructures=None,\\n ellipsoid_matrix_allStructures=None,\\n colors=None,\\n show_canonical_centroid=True,\\n xlim=(0,400),\\n ylim=(0,400),\\n zlim=(0,400),\\n xlabel='x',\\n ylabel='y',\\n zlabel='z',\\n title='Centroid means and covariances'):\\n\\n # Load ellipsoid: three radius and axes.\\n if radii_allStructures is not None and ellipsoid_matrix_allStructures is not None:\\n pass\\n elif cov_mat_allStructures is not None:\\n radii_allStructures, ellipsoid_matrix_allStructures = compute_ellipsoid_from_covar(cov_mat_allStructures)\\n else:\\n _, radii_allStructures, ellipsoid_matrix_allStructures = compute_covar_from_instance_centroids(instance_centroids)\\n\\n # Plot in 3D.\\n\\n from mpl_toolkits.mplot3d import Axes3D\\n from metadata import name_unsided_to_color, convert_to_original_name\\n\\n fig = plt.figure(figsize=(20, 20))\\n ax = fig.add_subplot(111, projection='3d')\\n\\n if colors is None:\\n colors = {name_s: (0,0,1) for name_s in instance_centroids}\\n\\n for name_s, centroids in instance_centroids.iteritems():\\n # if name_s == '7N_L' or name_s == '7N_R':\\n\\n if canonical_centroid is None:\\n centroids2 = np.array(centroids)\\n else:\\n centroids2 = np.array(centroids) + canonical_centroid\\n\\n ax.scatter(centroids2[:,0], centroids2[:,1], centroids2[:,2],\\n marker='o', s=100, alpha=.1, color=colors[name_s])\\n\\n if canonical_centroid is None:\\n c = nominal_locations[name_s]\\n else:\\n c = nominal_locations[name_s] + canonical_centroid\\n\\n ax.scatter(c[0], c[1], c[2],\\n color=colors[name_s], marker='*', s=100)\\n\\n # Plot uncerntainty ellipsoids\\n u = np.linspace(0.0, 2.0 * np.pi, 100)\\n v = np.linspace(0.0, np.pi, 100)\\n x = radii_allStructures[name_s][0] * np.outer(np.cos(u), np.sin(v))\\n y = radii_allStructures[name_s][1] * np.outer(np.sin(u), np.sin(v))\\n z = radii_allStructures[name_s][2] * np.outer(np.ones_like(u), np.cos(v))\\n for i in range(len(u)):\\n for j in range(len(v)):\\n [x[i,j],y[i,j],z[i,j]] = np.dot([x[i,j],y[i,j],z[i,j]], ellipsoid_matrix_allStructures[name_s]) + c\\n\\n # ax.plot_surface(x, y, z, color='b')\\n ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2)\\n\\n if canonical_centroid is not None:\\n if show_canonical_centroid:\\n ax.scatter(canonical_centroid[0], canonical_centroid[1], canonical_centroid[2],\\n color=(0,0,0), marker='^', s=200)\\n\\n # Plot mid-sagittal plane\\n if canonical_normal is not None:\\n canonical_midplane_xx, canonical_midplane_yy = np.meshgrid(range(xlim[0], xlim[1], 100), range(ylim[0], ylim[1], 100), indexing='xy')\\n canonical_midplane_z = -(canonical_normal[0]*(canonical_midplane_xx-canonical_centroid[0]) + \\\\\\n canonical_normal[1]*(canonical_midplane_yy-canonical_centroid[1]) + \\\\\\n canonical_normal[2]*(-canonical_centroid[2]))/canonical_normal[2]\\n ax.plot_surface(canonical_midplane_xx, canonical_midplane_yy, canonical_midplane_z, alpha=.1)\\n else:\\n sys.stderr.write(\\\"canonical_centroid not provided. Skip plotting cenonical centroid and mid-sagittal plane.\\\\n\\\")\\n\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n ax.set_zlabel(zlabel)\\n # ax.set_axis_off()\\n ax.set_xlim3d([xlim[0], xlim[1]]);\\n ax.set_ylim3d([ylim[0], ylim[1]]);\\n ax.set_zlim3d([zlim[0], zlim[1]]);\\n # ax.view_init(azim = 90 + 20,elev = 0 - 20)\\n ax.view_init(azim = 270, elev = 0)\\n\\n # Hide y-axis (https://stackoverflow.com/questions/12391271/matplotlib-turn-off-z-axis-only-in-3-d-plot)\\n ax.w_yaxis.line.set_lw(0.)\\n ax.set_yticks([])\\n\\n ax.set_aspect(1.0)\\n ax.set_title(title)\\n plt.legend()\\n plt.show()\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def init_centers(self, S, labels):\\n unique_labels = np.unique(labels)\\n centers = None\\n\\n for label in unique_labels:\\n idx = np.squeeze(labels == label)\\n cur_S = S[idx, :]\\n cur_center = np.mean(cur_S, axis=0)\\n if centers is None:\\n centers = cur_center\\n else:\\n centers = np.vstack((centers, cur_center))\\n centers = np.asarray(centers, dtype=floatX)\\n self.C.set_value(centers)\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def centroids(self):\\n return self.mdm_.covmeans_\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def computeCenters3d(self, data):\\n\\n\\n for i in range(self.nPoints):\\n print(\\\"Label of point \\\", i, \\\" is \\\", self.labels[i])\\n for j in range(3):\\n self.centers[self.labels[i]][j] += data[i][j]\\n\\n for c in range(self.n):\\n for j in range(3):\\n self.centers[c][j] /= self.tots[c]\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def initClusters(self):\\n if len(self.labelList) != len(self.pointList):\\n \\traise ValueError(\\\"Label List and Point List not the same length!\\\")\\n for i in range(len(self.labelList)):\\n self.centroids[self.labelList[i]] = self.pointList[i]\\n self.pointcounts[self.labelList[i]] = 1\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def mergeCenters(nCenters):\\r\\n\\tpath = os.getcwd()\\r\\n\\tos.chdir('Centers/')\\r\\n\\tcenter = np.zeros((0,128))\\t\\t#: Populator for centers\\r\\n\\r\\n\\tfor i in os.listdir(os.getcwd()):\\r\\n\\t Center = open(i,\\\"rb\\\")\\t\\t#: File pointer for centers file\\r\\n\\t center = np.vstack((center, pickle.load(Center)))\\t#Populate centers\\r\\n\\t Center.close()\\r\\n\\r\\n\\tcenter = np.float32(center)\\r\\n\\tcriteria = (cv2.TERM_CRITERIA_MAX_ITER, 10,0.0001)\\r\\n\\t#Checking version of opencv..\\r\\n\\tif __verison__[0] == '3':\\r\\n\\t\\tret,label,center=cv2.kmeans(center,int(nCenters),None,criteria,50,cv2.KMEANS_PP_CENTERS)\\r\\n\\telse:\\r\\n\\t\\tret,label,center=cv2.kmeans(center,int(nCenters),criteria,50,cv2.KMEANS_PP_CENTERS)\\r\\n\\r\\n\\tCenterFinal = open(path+'/centerFinal.p',\\\"wb\\\")#: File pointer for final centers file\\r\\n\\tpickle.dump(center, CenterFinal)\\t#Dump centers to file\\r\\n\\tCenterFinal.close()\",\n \"def centers(self):\\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)\",\n \"def calculate_centroids(self, data, clusters):\\n centroids = []\\n for i in range(self.n_clusters):\\n mask = clusters == i \\n centroids.append(np.mean(data[mask, :], axis = 0)) \\n return centroids\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def xcenters(self):\\n return self.centers[0]\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def centroid(coords,masses,divider):\\n\\treturn np.array([np.dot(masses[r].T,coords[r])/np.sum(masses[r]) for r in divider])\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def update(self, clusters):\\n centroids = {}\\n for cluster, coordinates in clusters.iteritems():\\n sumLat = 0\\n sumLong = 0\\n for coordinate in coordinates:\\n sumLat += float(coordinate[0])\\n sumLong += float(coordinate[1])\\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\\n return centroids\",\n \"def plot(X, clusters, cluster_num):\\n centroids = []\\n X = np.asarray(X)\\n for i in range(0,cluster_num):\\n centroids.append(clusters[i].centroid)\\n \\n np_centroids = np.asarray(centroids)\\n \\n color = [\\\"g\\\", \\\"r\\\", \\\"b\\\", \\\"c\\\", \\\"m\\\", \\\"b\\\"]\\n \\n fig = figure()\\n ax = fig.gca(projection='3d')\\n for i in range(len(X)):\\n ax.scatter(X[i][0], X[i][1], X[i][2], c=color)\\n \\n ax.scatter(np_centroids[:, 0],np_centroids[:, 1],\\n np_centroids[:, 2], marker = \\\"x\\\", s=150,\\n linewidths = 5, zorder = 100, c=color\\n )\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def __init__(self,\\n n_clusters=0,\\n centroids=None,\\n data=None,\\n labels=[],\\n distance='cov',\\n threshold=0.38,\\n dimension=128,\\n update_centroids=True):\\n self.n_clusters = n_clusters\\n self.threshold = threshold\\n self.distance = distance\\n self.dimension = dimension\\n self.update_centroids = update_centroids\\n if centroids is None:\\n self.centroids = np.zeros((n_clusters, 1, dimension))\\n else:\\n self.centroids = np.array(centroids)\\n\\n # if data is None:\\n # self.data = np.zeros((n_clusters, 1, dimension))\\n # else:\\n # self.data = np.array(data)\\n self.labels = np.array(labels, dtype=np.int32)\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\\n\\n if random_state is not None: np.random.seed(random_state)\\n\\n n_samples = n_samples//n_cluster\\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\\n\\n for cluster_idx in range(n_cluster):\\n # Group indicator\\n #group = sp.binom.rvs(p=0.25, n=1, size=N\\n n_neg = int(n_samples*(1-pos_ratio))\\n n_pos = n_samples-n_neg\\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\\n\\n idx_dependent = n_var - n_dependent\\n\\n if mean is None:\\n basic_mean = 0 #np.random.uniform(size=no_var)\\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n else:\\n mean0 = mean[cluster_idx][0]\\n mean1 = mean[cluster_idx][1]\\n \\n\\n # # Noise are variables with same distribution in majority and minority class\\n # if noise_ratio != 0:\\n # n_noise = int(noise_ratio*n_var)\\n # noise_idx = n_var - n_noise\\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\\n # size=n_samples).reshape([n_samples,-1])\\n \\n cov0, cov1 = None, None\\n\\n X1 = []\\n X0 = []\\n # Independent variables\\n if n_var-n_dependent > 0:\\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\\n\\n # Dependent variables\\n if n_dependent>0:\\n if cov is None:\\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n else:\\n cov0 = cov[cluster_idx][0]\\n cov1 = cov[cluster_idx][1]\\n\\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\\n cov= cov1, size=n_pos)\\n )\\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\\n cov= cov0, size=n_neg)\\n )\\n \\n X0 = np.hstack([*X0])\\n X1 = np.hstack([*X1])\\n X_cluster.append(np.vstack([X0, X1]))\\n #X = np.hstack([X, X_noise])\\n\\n mean0_cluster.append(mean0)\\n mean1_cluster.append(mean1)\\n cov0_cluster.append(cov0)\\n cov1_cluster.append(cov1)\\n\\n if n_cluster == 1:\\n X = X_cluster[0]\\n y = y_cluster[0]\\n else:\\n X = np.vstack(X_cluster)\\n y = np.hstack(y_cluster)\\n\\n #return {\\\"X\\\":X, \\\"y\\\":y,\\\"mean0\\\":mean0,\\\"mean1\\\":mean1, \\\"cov0\\\":cov0, \\\"cov1\\\":cov1}\\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def compute_covar_from_instance_centroids(instance_centroids):\\n\\n cov_mat_allStructures = {}\\n radii_allStructures = {}\\n ellipsoid_matrix_allStructures = {}\\n for name_s, centroids in sorted(instance_centroids.items()):\\n centroids2 = np.array(centroids)\\n cov_mat = np.cov(centroids2.T)\\n cov_mat_allStructures[name_s] = cov_mat\\n u, s, vt = np.linalg.svd(cov_mat)\\n # print name_s, u[:,0], u[:,1], u[:,2],\\n radii_allStructures[name_s] = np.sqrt(s)\\n ellipsoid_matrix_allStructures[name_s] = vt\\n\\n return cov_mat_allStructures, radii_allStructures, ellipsoid_matrix_allStructures\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def fit_satellite_centers(image, spotcenters_init, window=20):\\n # fit satellite centers\\n scs = np.zeros((len(spotcenters_init), 2))\\n for idx,xy in enumerate(spotcenters_init):\\n subim = pre.subimage(image, xy, window=window)\\n popt = snm.image_centroid_gaussian1(subim)\\n xcenp = popt[1]\\n ycenp = popt[2]\\n xcen = xy[0]-round(window/2)+xcenp\\n ycen = xy[1]-round(window/2)+ycenp\\n scs[idx,:] = xcen, ycen \\n \\n return scs\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def centers(self):\\n def make_centers(x):\\n return 0.25 * (x[:-1, :-1] + x[:-1, 1:] + x[1:, :-1] + x[1:, 1:])\\n\\n polar_centers = make_centers(self.polar_corners)\\n azimuthal_centers = make_centers(self.azimuthal_corners)\\n\\n assert azimuthal_centers.shape == polar_centers.shape\\n return polar_centers, azimuthal_centers\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\\n self.n = n\\n self.d = d\\n\\n # 95% of data lies in a 2*sigma ball around the mean.\\n # For unit variance normal, the 2*sigma ball mean the centers\\n # should be at distance of 4 in the d dimensional space.\\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\\n cov = np.eye(d)\\n\\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\\n # print(dist_mean)\\n # cov = np.eye(d)\\n\\n frac = int(1 / pos_fraction)\\n\\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\\n\\n self.X = np.vstack((cluster1, cluster2))\\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\\n\\n # Make blobs\\n # if True:\\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def __get_initial_centroid(self, x_train, seed=None):\\n if self.init == \\\"random\\\":\\n # randomly select n_cluster point from the input dataset\\n if seed:\\n random.seed(seed)\\n return np.asarray(random.choices(x_train, k=self.n_cluster))\",\n \"def calcCentroid(self):\\n size = len(self.vectors)\\n # zip all features together\\n zipped = zip(*self.vectors)\\n # Calculate the mean for each feature/column\\n centroid = [math.fsum(column)/size for column in zipped]\\n \\n return centroid\",\n \"def centroid(sign, FS):\\n\\n time = compute_time(sign, FS)\\n\\n energy, time_energy=signal_energy(sign, time)\\n\\n total_energy = np.dot(np.array(time_energy),np.array(energy))\\n energy_sum = np.sum(energy)\\n\\n if energy_sum == 0 or total_energy == 0:\\n centroid = 0\\n else:\\n centroid = total_energy / energy_sum\\n return centroid\",\n \"def _init_centroid(self, data):\\n\\n\\t\\tcentroids = data[:self._k]\\n\\t\\tx_assignee = data\\n\\n\\t\\treturn centroids, x_assignee\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def k_means_cc(self, X_columns, y_column, k, n_features=0):\\n try:\\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\\n \\n\\n fig = plt.figure(1)\\n fig.subplots_adjust(hspace=0.5)\\n for x in range(0,centroids.shape[1]):\\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\\n cmap = 'Set1'\\n for c in range(centroids.shape[0]):\\n temp_df = labeled_features[labeled_features['clusters'] == c]\\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\\n ax.set_xlabel(labeled_features.columns[x])\\n ax.axis('tight')\\n if(x == 0):\\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\\n plt.annotate(\\\"Silhouette Coefficient: \\\"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\\n plt.suptitle(\\\"Scatter Plot of \\\"+labeled_features.columns[0]+\\\" against other Features\\\")\\n \\n fig2 = plt.figure(2)\\n ax2 = fig2.subplots()\\n for k in range(centroids.shape[0]):\\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\\\": \\\"+str(centroids[k]))\\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\\n plt.xlabel(\\\"Features\\\")\\n plt.ylabel(\\\"Location\\\")\\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\\\"left\\\" )\\n plt.legend(loc=\\\"upper right\\\",title='Clusters (Centroids)')\\n plt.title(\\\"Centroid Chart (\\\"+y_column+\\\")\\\")\\n plt.tight_layout()\\n\\n plt.show()\\n\\n except Exception as e:\\n print(e)\",\n \"def __init__(self, init_centers):\\n\\n assert len(init_centers.shape) == 2, f\\\"init_centers should be a KxD matrix. Got: {init_centers.shape}\\\"\\n (self.K, self.D) = init_centers.shape\\n assert self.K > 1, f\\\"There must be at least 2 clusters. Got: {self.K}\\\"\\n\\n # Shape: K x D\\n self.centers = np.copy(init_centers)\",\n \"def consolidate(params, centroid_m=(0,0,0), centroid_f=(0,0,0)):\\n G = params.reshape((3,4))\\n R = G[:3,:3]\\n t = - np.dot(R, centroid_m) + G[:3,3] + centroid_f\\n return np.vstack([np.c_[R,t], [0,0,0,1]])\",\n \"def calculate_cluster_center(self, threshold):\\n gamma = self.gamma\\n self.cluster_center = np.where(gamma >= threshold)[0]\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def get_element_centroids(self):\\n if self.centroids is None:\\n self.centroids = np.vstack((\\n np.mean(self.grid['x'], axis=1),\\n np.mean(self.grid['z'], axis=1)\\n )).T\\n\\n return self.centroids\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def __cmeans(self, points, nclusters):\\n # load list of points for cluster analysis\\n # initialize\\n initial_centers = kmeans_plusplus_initializer(points, nclusters, kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE).initialize()\\n # create instance of Fuzzy C-Means algorithm\\n fcm_instance = fcm(points, initial_centers)\\n # run cluster analysis and obtain results\\n fcm_instance.process()\\n clusters = fcm_instance.get_clusters()\\n centers = fcm_instance.get_centers()\\n membership = fcm_instance.get_membership()\\n return clusters, centers, membership\",\n \"def atlas_clusters():\\n pass\",\n \"def compute_variance(\\n data, cluster_labels, centroids, alpha=10, debug=False, num_class=None\\n):\\n\\n k = len(centroids) if num_class is None else num_class\\n phis = torch.zeros(k)\\n for c in range(k):\\n cluster_points = data[cluster_labels == c]\\n c_len = len(cluster_points)\\n if c_len == 0:\\n phis[c] = -1\\n elif c_len == 1:\\n phis[c] = 0.05\\n else:\\n phis[c] = torch.sum(torch.norm(cluster_points - centroids[c], dim=1)) / (\\n c_len * np.log(c_len + alpha)\\n )\\n if phis[c] < 0.05:\\n phis[c] = 0.05\\n\\n if debug:\\n print(\\\"size-phi:\\\", end=\\\" \\\")\\n for i in range(k):\\n size = (cluster_labels == i).sum().item()\\n print(f\\\"{size}[phi={phis[i].item():.3f}]\\\", end=\\\", \\\")\\n print(\\\"\\\\n\\\")\\n\\n return phis\",\n \"def initiateCentroid(data_points, centroids, k):\\n #Create empty list in list (amount is k)\\n AvgCentroids = [[] for i in range(k)]\\n\\n #For each datapoint in all datapoints\\n for dp in data_points:\\n dis = []\\n #For each centroid in centroids\\n for c in range(len(centroids)):\\n #Calculate the euclidean distance between those points and append\\n #to distance list\\n dis.append(calcEuclideanDistance(dp, centroids[c]))\\n \\n #Get the smallest value of the list and the index\\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\\n\\n #The index of the smallest value is the index where it will be added\\n #to the avgCentroids list. So it represents the number of the cluster\\n AvgCentroids[idx].append(dp)\\n \\n return AvgCentroids\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6578101","0.6553022","0.6369997","0.63132054","0.62990874","0.62756854","0.62509024","0.6190687","0.6112884","0.6097691","0.60697997","0.60543525","0.5993539","0.598463","0.5970525","0.5952007","0.5925367","0.5922735","0.5904544","0.590372","0.590219","0.5841981","0.58257693","0.5815215","0.5813656","0.5813656","0.5795831","0.57925916","0.5792294","0.5787281","0.57450235","0.5742606","0.57409745","0.5734606","0.57236874","0.5717936","0.5714472","0.57105327","0.5702588","0.57021767","0.5689891","0.5686098","0.56777215","0.5676316","0.5672407","0.5671741","0.56690186","0.5646279","0.5631958","0.5616523","0.5614644","0.56116","0.56101996","0.56005216","0.55791825","0.55764174","0.55709493","0.5559066","0.55587405","0.55395687","0.5519886","0.5514501","0.55144185","0.5500609","0.550056","0.5498631","0.5496987","0.54859126","0.5485847","0.54828304","0.54730463","0.54724616","0.5471106","0.54644775","0.5460543","0.54594994","0.54582566","0.54462576","0.54411036","0.5439271","0.54387945","0.5437237","0.5426379","0.5424988","0.54165244","0.54106355","0.5395007","0.5392658","0.5387452","0.53853613","0.5384254","0.5372136","0.5365165","0.535175","0.5345078","0.534404","0.5342824","0.5342586","0.53417146","0.5339238"],"string":"[\n \"0.6578101\",\n \"0.6553022\",\n \"0.6369997\",\n \"0.63132054\",\n \"0.62990874\",\n \"0.62756854\",\n \"0.62509024\",\n \"0.6190687\",\n \"0.6112884\",\n \"0.6097691\",\n \"0.60697997\",\n \"0.60543525\",\n \"0.5993539\",\n \"0.598463\",\n \"0.5970525\",\n \"0.5952007\",\n \"0.5925367\",\n \"0.5922735\",\n \"0.5904544\",\n \"0.590372\",\n \"0.590219\",\n \"0.5841981\",\n \"0.58257693\",\n \"0.5815215\",\n \"0.5813656\",\n \"0.5813656\",\n \"0.5795831\",\n \"0.57925916\",\n \"0.5792294\",\n \"0.5787281\",\n \"0.57450235\",\n \"0.5742606\",\n \"0.57409745\",\n \"0.5734606\",\n \"0.57236874\",\n \"0.5717936\",\n \"0.5714472\",\n \"0.57105327\",\n \"0.5702588\",\n \"0.57021767\",\n \"0.5689891\",\n \"0.5686098\",\n \"0.56777215\",\n \"0.5676316\",\n \"0.5672407\",\n \"0.5671741\",\n \"0.56690186\",\n \"0.5646279\",\n \"0.5631958\",\n \"0.5616523\",\n \"0.5614644\",\n \"0.56116\",\n \"0.56101996\",\n \"0.56005216\",\n \"0.55791825\",\n \"0.55764174\",\n \"0.55709493\",\n \"0.5559066\",\n \"0.55587405\",\n \"0.55395687\",\n \"0.5519886\",\n \"0.5514501\",\n \"0.55144185\",\n \"0.5500609\",\n \"0.550056\",\n \"0.5498631\",\n \"0.5496987\",\n \"0.54859126\",\n \"0.5485847\",\n \"0.54828304\",\n \"0.54730463\",\n \"0.54724616\",\n \"0.5471106\",\n \"0.54644775\",\n \"0.5460543\",\n \"0.54594994\",\n \"0.54582566\",\n \"0.54462576\",\n \"0.54411036\",\n \"0.5439271\",\n \"0.54387945\",\n \"0.5437237\",\n \"0.5426379\",\n \"0.5424988\",\n \"0.54165244\",\n \"0.54106355\",\n \"0.5395007\",\n \"0.5392658\",\n \"0.5387452\",\n \"0.53853613\",\n \"0.5384254\",\n \"0.5372136\",\n \"0.5365165\",\n \"0.535175\",\n \"0.5345078\",\n \"0.534404\",\n \"0.5342824\",\n \"0.5342586\",\n \"0.53417146\",\n \"0.5339238\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5482319"},"document_rank":{"kind":"string","value":"70"}}},{"rowIdx":9485,"cells":{"query":{"kind":"string","value":"Create 4 cluster centers. Create gaussians centered at (10,10), (10,10), (10,10) and (10,10). Each has standard covariance."},"document":{"kind":"string","value":"def _4_normal_spread():\n return [mn(mean=np.array([10.0, 10.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([10.0, -10.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([-10.0, -10.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]])),\n mn(mean=np.array([-10.0, 10.0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))]"},"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 random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def plot_centroid_means_and_covars_3d(instance_centroids,\n nominal_locations,\n canonical_centroid=None,\n canonical_normal=None,\n cov_mat_allStructures=None,\n radii_allStructures=None,\n ellipsoid_matrix_allStructures=None,\n colors=None,\n show_canonical_centroid=True,\n xlim=(0,400),\n ylim=(0,400),\n zlim=(0,400),\n xlabel='x',\n ylabel='y',\n zlabel='z',\n title='Centroid means and covariances'):\n\n # Load ellipsoid: three radius and axes.\n if radii_allStructures is not None and ellipsoid_matrix_allStructures is not None:\n pass\n elif cov_mat_allStructures is not None:\n radii_allStructures, ellipsoid_matrix_allStructures = compute_ellipsoid_from_covar(cov_mat_allStructures)\n else:\n _, radii_allStructures, ellipsoid_matrix_allStructures = compute_covar_from_instance_centroids(instance_centroids)\n\n # Plot in 3D.\n\n from mpl_toolkits.mplot3d import Axes3D\n from metadata import name_unsided_to_color, convert_to_original_name\n\n fig = plt.figure(figsize=(20, 20))\n ax = fig.add_subplot(111, projection='3d')\n\n if colors is None:\n colors = {name_s: (0,0,1) for name_s in instance_centroids}\n\n for name_s, centroids in instance_centroids.iteritems():\n # if name_s == '7N_L' or name_s == '7N_R':\n\n if canonical_centroid is None:\n centroids2 = np.array(centroids)\n else:\n centroids2 = np.array(centroids) + canonical_centroid\n\n ax.scatter(centroids2[:,0], centroids2[:,1], centroids2[:,2],\n marker='o', s=100, alpha=.1, color=colors[name_s])\n\n if canonical_centroid is None:\n c = nominal_locations[name_s]\n else:\n c = nominal_locations[name_s] + canonical_centroid\n\n ax.scatter(c[0], c[1], c[2],\n color=colors[name_s], marker='*', s=100)\n\n # Plot uncerntainty ellipsoids\n u = np.linspace(0.0, 2.0 * np.pi, 100)\n v = np.linspace(0.0, np.pi, 100)\n x = radii_allStructures[name_s][0] * np.outer(np.cos(u), np.sin(v))\n y = radii_allStructures[name_s][1] * np.outer(np.sin(u), np.sin(v))\n z = radii_allStructures[name_s][2] * np.outer(np.ones_like(u), np.cos(v))\n for i in range(len(u)):\n for j in range(len(v)):\n [x[i,j],y[i,j],z[i,j]] = np.dot([x[i,j],y[i,j],z[i,j]], ellipsoid_matrix_allStructures[name_s]) + c\n\n # ax.plot_surface(x, y, z, color='b')\n ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2)\n\n if canonical_centroid is not None:\n if show_canonical_centroid:\n ax.scatter(canonical_centroid[0], canonical_centroid[1], canonical_centroid[2],\n color=(0,0,0), marker='^', s=200)\n\n # Plot mid-sagittal plane\n if canonical_normal is not None:\n canonical_midplane_xx, canonical_midplane_yy = np.meshgrid(range(xlim[0], xlim[1], 100), range(ylim[0], ylim[1], 100), indexing='xy')\n canonical_midplane_z = -(canonical_normal[0]*(canonical_midplane_xx-canonical_centroid[0]) + \\\n canonical_normal[1]*(canonical_midplane_yy-canonical_centroid[1]) + \\\n canonical_normal[2]*(-canonical_centroid[2]))/canonical_normal[2]\n ax.plot_surface(canonical_midplane_xx, canonical_midplane_yy, canonical_midplane_z, alpha=.1)\n else:\n sys.stderr.write(\"canonical_centroid not provided. Skip plotting cenonical centroid and mid-sagittal plane.\\n\")\n\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n ax.set_zlabel(zlabel)\n # ax.set_axis_off()\n ax.set_xlim3d([xlim[0], xlim[1]]);\n ax.set_ylim3d([ylim[0], ylim[1]]);\n ax.set_zlim3d([zlim[0], zlim[1]]);\n # ax.view_init(azim = 90 + 20,elev = 0 - 20)\n ax.view_init(azim = 270, elev = 0)\n\n # Hide y-axis (https://stackoverflow.com/questions/12391271/matplotlib-turn-off-z-axis-only-in-3-d-plot)\n ax.w_yaxis.line.set_lw(0.)\n ax.set_yticks([])\n\n ax.set_aspect(1.0)\n ax.set_title(title)\n plt.legend()\n plt.show()","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def init_centers(self, S, labels):\n unique_labels = np.unique(labels)\n centers = None\n\n for label in unique_labels:\n idx = np.squeeze(labels == label)\n cur_S = S[idx, :]\n cur_center = np.mean(cur_S, axis=0)\n if centers is None:\n centers = cur_center\n else:\n centers = np.vstack((centers, cur_center))\n centers = np.asarray(centers, dtype=floatX)\n self.C.set_value(centers)","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def centroids(self):\n return self.mdm_.covmeans_","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def computeCenters3d(self, data):\n\n\n for i in range(self.nPoints):\n print(\"Label of point \", i, \" is \", self.labels[i])\n for j in range(3):\n self.centers[self.labels[i]][j] += data[i][j]\n\n for c in range(self.n):\n for j in range(3):\n self.centers[c][j] /= self.tots[c]","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def initClusters(self):\n if len(self.labelList) != len(self.pointList):\n \traise ValueError(\"Label List and Point List not the same length!\")\n for i in range(len(self.labelList)):\n self.centroids[self.labelList[i]] = self.pointList[i]\n self.pointcounts[self.labelList[i]] = 1","def mergeCenters(nCenters):\r\n\tpath = os.getcwd()\r\n\tos.chdir('Centers/')\r\n\tcenter = np.zeros((0,128))\t\t#: Populator for centers\r\n\r\n\tfor i in os.listdir(os.getcwd()):\r\n\t Center = open(i,\"rb\")\t\t#: File pointer for centers file\r\n\t center = np.vstack((center, pickle.load(Center)))\t#Populate centers\r\n\t Center.close()\r\n\r\n\tcenter = np.float32(center)\r\n\tcriteria = (cv2.TERM_CRITERIA_MAX_ITER, 10,0.0001)\r\n\t#Checking version of opencv..\r\n\tif __verison__[0] == '3':\r\n\t\tret,label,center=cv2.kmeans(center,int(nCenters),None,criteria,50,cv2.KMEANS_PP_CENTERS)\r\n\telse:\r\n\t\tret,label,center=cv2.kmeans(center,int(nCenters),criteria,50,cv2.KMEANS_PP_CENTERS)\r\n\r\n\tCenterFinal = open(path+'/centerFinal.p',\"wb\")#: File pointer for final centers file\r\n\tpickle.dump(center, CenterFinal)\t#Dump centers to file\r\n\tCenterFinal.close()","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def calculate_centroids(self, data, clusters):\n centroids = []\n for i in range(self.n_clusters):\n mask = clusters == i \n centroids.append(np.mean(data[mask, :], axis = 0)) \n return centroids","def plot(X, clusters, cluster_num):\n centroids = []\n X = np.asarray(X)\n for i in range(0,cluster_num):\n centroids.append(clusters[i].centroid)\n \n np_centroids = np.asarray(centroids)\n \n color = [\"g\", \"r\", \"b\", \"c\", \"m\", \"b\"]\n \n fig = figure()\n ax = fig.gca(projection='3d')\n for i in range(len(X)):\n ax.scatter(X[i][0], X[i][1], X[i][2], c=color)\n \n ax.scatter(np_centroids[:, 0],np_centroids[:, 1],\n np_centroids[:, 2], marker = \"x\", s=150,\n linewidths = 5, zorder = 100, c=color\n )","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def update(self, clusters):\n centroids = {}\n for cluster, coordinates in clusters.iteritems():\n sumLat = 0\n sumLong = 0\n for coordinate in coordinates:\n sumLat += float(coordinate[0])\n sumLong += float(coordinate[1])\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\n return centroids","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def centers(self):\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)","def __init__(self,\n n_clusters=0,\n centroids=None,\n data=None,\n labels=[],\n distance='cov',\n threshold=0.38,\n dimension=128,\n update_centroids=True):\n self.n_clusters = n_clusters\n self.threshold = threshold\n self.distance = distance\n self.dimension = dimension\n self.update_centroids = update_centroids\n if centroids is None:\n self.centroids = np.zeros((n_clusters, 1, dimension))\n else:\n self.centroids = np.array(centroids)\n\n # if data is None:\n # self.data = np.zeros((n_clusters, 1, dimension))\n # else:\n # self.data = np.array(data)\n self.labels = np.array(labels, dtype=np.int32)","def fit_satellite_centers(image, spotcenters_init, window=20):\n # fit satellite centers\n scs = np.zeros((len(spotcenters_init), 2))\n for idx,xy in enumerate(spotcenters_init):\n subim = pre.subimage(image, xy, window=window)\n popt = snm.image_centroid_gaussian1(subim)\n xcenp = popt[1]\n ycenp = popt[2]\n xcen = xy[0]-round(window/2)+xcenp\n ycen = xy[1]-round(window/2)+ycenp\n scs[idx,:] = xcen, ycen \n \n return scs","def centroid(coords,masses,divider):\n\treturn np.array([np.dot(masses[r].T,coords[r])/np.sum(masses[r]) for r in divider])","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def xcenters(self):\n return self.centers[0]","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def centers(self):\n def make_centers(x):\n return 0.25 * (x[:-1, :-1] + x[:-1, 1:] + x[1:, :-1] + x[1:, 1:])\n\n polar_centers = make_centers(self.polar_corners)\n azimuthal_centers = make_centers(self.azimuthal_corners)\n\n assert azimuthal_centers.shape == polar_centers.shape\n return polar_centers, azimuthal_centers","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def k_means_cc(self, X_columns, y_column, k, n_features=0):\n try:\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\n \n\n fig = plt.figure(1)\n fig.subplots_adjust(hspace=0.5)\n for x in range(0,centroids.shape[1]):\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\n cmap = 'Set1'\n for c in range(centroids.shape[0]):\n temp_df = labeled_features[labeled_features['clusters'] == c]\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\n ax.set_xlabel(labeled_features.columns[x])\n ax.axis('tight')\n if(x == 0):\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\n plt.annotate(\"Silhouette Coefficient: \"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\n plt.suptitle(\"Scatter Plot of \"+labeled_features.columns[0]+\" against other Features\")\n \n fig2 = plt.figure(2)\n ax2 = fig2.subplots()\n for k in range(centroids.shape[0]):\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\": \"+str(centroids[k]))\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\n plt.xlabel(\"Features\")\n plt.ylabel(\"Location\")\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\"left\" )\n plt.legend(loc=\"upper right\",title='Clusters (Centroids)')\n plt.title(\"Centroid Chart (\"+y_column+\")\")\n plt.tight_layout()\n\n plt.show()\n\n except Exception as e:\n print(e)","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def _init_centroid(self, data):\n\n\t\tcentroids = data[:self._k]\n\t\tx_assignee = data\n\n\t\treturn centroids, x_assignee","def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\n\n if random_state is not None: np.random.seed(random_state)\n\n n_samples = n_samples//n_cluster\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\n\n for cluster_idx in range(n_cluster):\n # Group indicator\n #group = sp.binom.rvs(p=0.25, n=1, size=N\n n_neg = int(n_samples*(1-pos_ratio))\n n_pos = n_samples-n_neg\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\n\n idx_dependent = n_var - n_dependent\n\n if mean is None:\n basic_mean = 0 #np.random.uniform(size=no_var)\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n else:\n mean0 = mean[cluster_idx][0]\n mean1 = mean[cluster_idx][1]\n \n\n # # Noise are variables with same distribution in majority and minority class\n # if noise_ratio != 0:\n # n_noise = int(noise_ratio*n_var)\n # noise_idx = n_var - n_noise\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\n # size=n_samples).reshape([n_samples,-1])\n \n cov0, cov1 = None, None\n\n X1 = []\n X0 = []\n # Independent variables\n if n_var-n_dependent > 0:\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\n\n # Dependent variables\n if n_dependent>0:\n if cov is None:\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n else:\n cov0 = cov[cluster_idx][0]\n cov1 = cov[cluster_idx][1]\n\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\n cov= cov1, size=n_pos)\n )\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\n cov= cov0, size=n_neg)\n )\n \n X0 = np.hstack([*X0])\n X1 = np.hstack([*X1])\n X_cluster.append(np.vstack([X0, X1]))\n #X = np.hstack([X, X_noise])\n\n mean0_cluster.append(mean0)\n mean1_cluster.append(mean1)\n cov0_cluster.append(cov0)\n cov1_cluster.append(cov1)\n\n if n_cluster == 1:\n X = X_cluster[0]\n y = y_cluster[0]\n else:\n X = np.vstack(X_cluster)\n y = np.hstack(y_cluster)\n\n #return {\"X\":X, \"y\":y,\"mean0\":mean0,\"mean1\":mean1, \"cov0\":cov0, \"cov1\":cov1}\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster","def __get_initial_centroid(self, x_train, seed=None):\n if self.init == \"random\":\n # randomly select n_cluster point from the input dataset\n if seed:\n random.seed(seed)\n return np.asarray(random.choices(x_train, k=self.n_cluster))","def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\n self.d = d\n\n # 95% of data lies in a 2*sigma ball around the mean.\n # For unit variance normal, the 2*sigma ball mean the centers\n # should be at distance of 4 in the d dimensional space.\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\n cov = np.eye(d)\n\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\n # print(dist_mean)\n # cov = np.eye(d)\n\n frac = int(1 / pos_fraction)\n\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\n\n self.X = np.vstack((cluster1, cluster2))\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\n\n # Make blobs\n # if True:\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def compute_covar_from_instance_centroids(instance_centroids):\n\n cov_mat_allStructures = {}\n radii_allStructures = {}\n ellipsoid_matrix_allStructures = {}\n for name_s, centroids in sorted(instance_centroids.items()):\n centroids2 = np.array(centroids)\n cov_mat = np.cov(centroids2.T)\n cov_mat_allStructures[name_s] = cov_mat\n u, s, vt = np.linalg.svd(cov_mat)\n # print name_s, u[:,0], u[:,1], u[:,2],\n radii_allStructures[name_s] = np.sqrt(s)\n ellipsoid_matrix_allStructures[name_s] = vt\n\n return cov_mat_allStructures, radii_allStructures, ellipsoid_matrix_allStructures","def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n\n # Scale the data so that Euclidian distance makes sense\n means = np.mean(data, axis = 0)\n stddevs = np.std(data, axis = 0, ddof = 1)\n\n #print(means)\n #print(stddevs)\n\n data_scaled = np.zeros((n_examples, n_features))\n\n for i in range(n_features):\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\n\n study_correlation(data_scaled)\n\n # Initialize the centroids\n idx = np.random.randint(n_examples, size = n_clusters)\n centroids = data_scaled[idx, :]\n\n counter = 0\n\n while True:\n\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\n centroid_idx = np.argmin(distances, axis = 1)\n old_centroids = centroids\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\n #displacement = get_displacement(old_centroids, centroids)\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\n\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\n\n if counter == 0:\n# print(\"Initial displacement = {}\".format(displacement))\n initial_displacement = displacement\n\n counter += 1\n\n if displacement < (initial_displacement / 10000): break\n\n #print(\"Total number of loops before ending : {}\".format(counter))\n converted_predictions = convert_predictions(centroid_idx)\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def initiateCentroid(data_points, centroids, k):\n #Create empty list in list (amount is k)\n AvgCentroids = [[] for i in range(k)]\n\n #For each datapoint in all datapoints\n for dp in data_points:\n dis = []\n #For each centroid in centroids\n for c in range(len(centroids)):\n #Calculate the euclidean distance between those points and append\n #to distance list\n dis.append(calcEuclideanDistance(dp, centroids[c]))\n \n #Get the smallest value of the list and the index\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\n\n #The index of the smallest value is the index where it will be added\n #to the avgCentroids list. So it represents the number of the cluster\n AvgCentroids[idx].append(dp)\n \n return AvgCentroids","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def get_viable_pos_cluster_centers(self, index, radius, cutoff, num_pts=None):\n\n viable_pos = self.get_viable_positions(index, radius, cutoff, num_pts)\n ms = MeanShift(bin_seeding=True)\n ms.fit(np.array(viable_pos))\n cluster_centers = ms.cluster_centers_\n return cluster_centers","def calculate_cluster_center(self, threshold):\n gamma = self.gamma\n self.cluster_center = np.where(gamma >= threshold)[0]","def __init__(self, init_centers):\n\n assert len(init_centers.shape) == 2, f\"init_centers should be a KxD matrix. Got: {init_centers.shape}\"\n (self.K, self.D) = init_centers.shape\n assert self.K > 1, f\"There must be at least 2 clusters. Got: {self.K}\"\n\n # Shape: K x D\n self.centers = np.copy(init_centers)","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def plot_clusters(true_data, preds, cluster_center, cluster_name, savefig=\"\", title=\"\"):\n\n colors = plt.cm.get_cmap('hsv', len(cluster_name)+1) # get colors for each cluster using get_cmap. This will give us len(cluster_name) colors in a object form.\n \n for i, c in enumerate(cluster_name): # iterate through each cluster name\n if c == -1: # -1 is given by DBScan for noise\n clrs = 'grey' # make it grey\n label = 'Noise' # label it 'Noise'\n else:\n clrs = colors(c) # get color for it\n label=f'Cluster {c}' # label it by its name\n df = true_data[preds == c] # get the points from dataset whose prediction was cluster `c`\n x, y = df.iloc[:, 0], df.iloc[:, 1] # x and y axis\n plt.scatter( # plotting the x and y axis\n x, y,\n label=label,\n color=clrs\n )\n if c != -1:\n plt.text(\n cluster_center[i][0] + 0.03, cluster_center[i][1] + 0.1,\n f\"Cluster {i}\",\n weight='bold',\n fontsize=9,\n )\n \n plt.scatter(\n cluster_center[:, 0], cluster_center[:, 1], # plotting the cluster centers\n s=250, marker='*',\n c='red', edgecolor='black',\n label='Centroids'\n )\n \n plt.title(title)\n plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n plt.tight_layout()\n if savefig != \"\" : plt.savefig(f\"{savefig}.png\")\n plt.show()\n plt.close()","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def centroid(sign, FS):\n\n time = compute_time(sign, FS)\n\n energy, time_energy=signal_energy(sign, time)\n\n total_energy = np.dot(np.array(time_energy),np.array(energy))\n energy_sum = np.sum(energy)\n\n if energy_sum == 0 or total_energy == 0:\n centroid = 0\n else:\n centroid = total_energy / energy_sum\n return centroid","def calcCentroid(self):\n size = len(self.vectors)\n # zip all features together\n zipped = zip(*self.vectors)\n # Calculate the mean for each feature/column\n centroid = [math.fsum(column)/size for column in zipped]\n \n return centroid","def __cmeans(self, points, nclusters):\n # load list of points for cluster analysis\n # initialize\n initial_centers = kmeans_plusplus_initializer(points, nclusters, kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE).initialize()\n # create instance of Fuzzy C-Means algorithm\n fcm_instance = fcm(points, initial_centers)\n # run cluster analysis and obtain results\n fcm_instance.process()\n clusters = fcm_instance.get_clusters()\n centers = fcm_instance.get_centers()\n membership = fcm_instance.get_membership()\n return clusters, centers, membership","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def assign_centroids(data, centroids) :\r\n distances = []\r\n for centroid in centroids :\r\n distances.append(np.linalg.norm(data - centroid, axis=1))\r\n distances = np.column_stack(distances)\r\n assigned_centroids = np.argmin(distances, axis=1).flatten()\r\n return assigned_centroids"],"string":"[\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def plot_centroid_means_and_covars_3d(instance_centroids,\\n nominal_locations,\\n canonical_centroid=None,\\n canonical_normal=None,\\n cov_mat_allStructures=None,\\n radii_allStructures=None,\\n ellipsoid_matrix_allStructures=None,\\n colors=None,\\n show_canonical_centroid=True,\\n xlim=(0,400),\\n ylim=(0,400),\\n zlim=(0,400),\\n xlabel='x',\\n ylabel='y',\\n zlabel='z',\\n title='Centroid means and covariances'):\\n\\n # Load ellipsoid: three radius and axes.\\n if radii_allStructures is not None and ellipsoid_matrix_allStructures is not None:\\n pass\\n elif cov_mat_allStructures is not None:\\n radii_allStructures, ellipsoid_matrix_allStructures = compute_ellipsoid_from_covar(cov_mat_allStructures)\\n else:\\n _, radii_allStructures, ellipsoid_matrix_allStructures = compute_covar_from_instance_centroids(instance_centroids)\\n\\n # Plot in 3D.\\n\\n from mpl_toolkits.mplot3d import Axes3D\\n from metadata import name_unsided_to_color, convert_to_original_name\\n\\n fig = plt.figure(figsize=(20, 20))\\n ax = fig.add_subplot(111, projection='3d')\\n\\n if colors is None:\\n colors = {name_s: (0,0,1) for name_s in instance_centroids}\\n\\n for name_s, centroids in instance_centroids.iteritems():\\n # if name_s == '7N_L' or name_s == '7N_R':\\n\\n if canonical_centroid is None:\\n centroids2 = np.array(centroids)\\n else:\\n centroids2 = np.array(centroids) + canonical_centroid\\n\\n ax.scatter(centroids2[:,0], centroids2[:,1], centroids2[:,2],\\n marker='o', s=100, alpha=.1, color=colors[name_s])\\n\\n if canonical_centroid is None:\\n c = nominal_locations[name_s]\\n else:\\n c = nominal_locations[name_s] + canonical_centroid\\n\\n ax.scatter(c[0], c[1], c[2],\\n color=colors[name_s], marker='*', s=100)\\n\\n # Plot uncerntainty ellipsoids\\n u = np.linspace(0.0, 2.0 * np.pi, 100)\\n v = np.linspace(0.0, np.pi, 100)\\n x = radii_allStructures[name_s][0] * np.outer(np.cos(u), np.sin(v))\\n y = radii_allStructures[name_s][1] * np.outer(np.sin(u), np.sin(v))\\n z = radii_allStructures[name_s][2] * np.outer(np.ones_like(u), np.cos(v))\\n for i in range(len(u)):\\n for j in range(len(v)):\\n [x[i,j],y[i,j],z[i,j]] = np.dot([x[i,j],y[i,j],z[i,j]], ellipsoid_matrix_allStructures[name_s]) + c\\n\\n # ax.plot_surface(x, y, z, color='b')\\n ax.plot_wireframe(x, y, z, rstride=4, cstride=4, color='b', alpha=0.2)\\n\\n if canonical_centroid is not None:\\n if show_canonical_centroid:\\n ax.scatter(canonical_centroid[0], canonical_centroid[1], canonical_centroid[2],\\n color=(0,0,0), marker='^', s=200)\\n\\n # Plot mid-sagittal plane\\n if canonical_normal is not None:\\n canonical_midplane_xx, canonical_midplane_yy = np.meshgrid(range(xlim[0], xlim[1], 100), range(ylim[0], ylim[1], 100), indexing='xy')\\n canonical_midplane_z = -(canonical_normal[0]*(canonical_midplane_xx-canonical_centroid[0]) + \\\\\\n canonical_normal[1]*(canonical_midplane_yy-canonical_centroid[1]) + \\\\\\n canonical_normal[2]*(-canonical_centroid[2]))/canonical_normal[2]\\n ax.plot_surface(canonical_midplane_xx, canonical_midplane_yy, canonical_midplane_z, alpha=.1)\\n else:\\n sys.stderr.write(\\\"canonical_centroid not provided. Skip plotting cenonical centroid and mid-sagittal plane.\\\\n\\\")\\n\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n ax.set_zlabel(zlabel)\\n # ax.set_axis_off()\\n ax.set_xlim3d([xlim[0], xlim[1]]);\\n ax.set_ylim3d([ylim[0], ylim[1]]);\\n ax.set_zlim3d([zlim[0], zlim[1]]);\\n # ax.view_init(azim = 90 + 20,elev = 0 - 20)\\n ax.view_init(azim = 270, elev = 0)\\n\\n # Hide y-axis (https://stackoverflow.com/questions/12391271/matplotlib-turn-off-z-axis-only-in-3-d-plot)\\n ax.w_yaxis.line.set_lw(0.)\\n ax.set_yticks([])\\n\\n ax.set_aspect(1.0)\\n ax.set_title(title)\\n plt.legend()\\n plt.show()\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def init_centers(self, S, labels):\\n unique_labels = np.unique(labels)\\n centers = None\\n\\n for label in unique_labels:\\n idx = np.squeeze(labels == label)\\n cur_S = S[idx, :]\\n cur_center = np.mean(cur_S, axis=0)\\n if centers is None:\\n centers = cur_center\\n else:\\n centers = np.vstack((centers, cur_center))\\n centers = np.asarray(centers, dtype=floatX)\\n self.C.set_value(centers)\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def centroids(self):\\n return self.mdm_.covmeans_\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def computeCenters3d(self, data):\\n\\n\\n for i in range(self.nPoints):\\n print(\\\"Label of point \\\", i, \\\" is \\\", self.labels[i])\\n for j in range(3):\\n self.centers[self.labels[i]][j] += data[i][j]\\n\\n for c in range(self.n):\\n for j in range(3):\\n self.centers[c][j] /= self.tots[c]\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def initClusters(self):\\n if len(self.labelList) != len(self.pointList):\\n \\traise ValueError(\\\"Label List and Point List not the same length!\\\")\\n for i in range(len(self.labelList)):\\n self.centroids[self.labelList[i]] = self.pointList[i]\\n self.pointcounts[self.labelList[i]] = 1\",\n \"def mergeCenters(nCenters):\\r\\n\\tpath = os.getcwd()\\r\\n\\tos.chdir('Centers/')\\r\\n\\tcenter = np.zeros((0,128))\\t\\t#: Populator for centers\\r\\n\\r\\n\\tfor i in os.listdir(os.getcwd()):\\r\\n\\t Center = open(i,\\\"rb\\\")\\t\\t#: File pointer for centers file\\r\\n\\t center = np.vstack((center, pickle.load(Center)))\\t#Populate centers\\r\\n\\t Center.close()\\r\\n\\r\\n\\tcenter = np.float32(center)\\r\\n\\tcriteria = (cv2.TERM_CRITERIA_MAX_ITER, 10,0.0001)\\r\\n\\t#Checking version of opencv..\\r\\n\\tif __verison__[0] == '3':\\r\\n\\t\\tret,label,center=cv2.kmeans(center,int(nCenters),None,criteria,50,cv2.KMEANS_PP_CENTERS)\\r\\n\\telse:\\r\\n\\t\\tret,label,center=cv2.kmeans(center,int(nCenters),criteria,50,cv2.KMEANS_PP_CENTERS)\\r\\n\\r\\n\\tCenterFinal = open(path+'/centerFinal.p',\\\"wb\\\")#: File pointer for final centers file\\r\\n\\tpickle.dump(center, CenterFinal)\\t#Dump centers to file\\r\\n\\tCenterFinal.close()\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def calculate_centroids(self, data, clusters):\\n centroids = []\\n for i in range(self.n_clusters):\\n mask = clusters == i \\n centroids.append(np.mean(data[mask, :], axis = 0)) \\n return centroids\",\n \"def plot(X, clusters, cluster_num):\\n centroids = []\\n X = np.asarray(X)\\n for i in range(0,cluster_num):\\n centroids.append(clusters[i].centroid)\\n \\n np_centroids = np.asarray(centroids)\\n \\n color = [\\\"g\\\", \\\"r\\\", \\\"b\\\", \\\"c\\\", \\\"m\\\", \\\"b\\\"]\\n \\n fig = figure()\\n ax = fig.gca(projection='3d')\\n for i in range(len(X)):\\n ax.scatter(X[i][0], X[i][1], X[i][2], c=color)\\n \\n ax.scatter(np_centroids[:, 0],np_centroids[:, 1],\\n np_centroids[:, 2], marker = \\\"x\\\", s=150,\\n linewidths = 5, zorder = 100, c=color\\n )\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def update(self, clusters):\\n centroids = {}\\n for cluster, coordinates in clusters.iteritems():\\n sumLat = 0\\n sumLong = 0\\n for coordinate in coordinates:\\n sumLat += float(coordinate[0])\\n sumLong += float(coordinate[1])\\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\\n return centroids\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def centers(self):\\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\",\n \"def __init__(self,\\n n_clusters=0,\\n centroids=None,\\n data=None,\\n labels=[],\\n distance='cov',\\n threshold=0.38,\\n dimension=128,\\n update_centroids=True):\\n self.n_clusters = n_clusters\\n self.threshold = threshold\\n self.distance = distance\\n self.dimension = dimension\\n self.update_centroids = update_centroids\\n if centroids is None:\\n self.centroids = np.zeros((n_clusters, 1, dimension))\\n else:\\n self.centroids = np.array(centroids)\\n\\n # if data is None:\\n # self.data = np.zeros((n_clusters, 1, dimension))\\n # else:\\n # self.data = np.array(data)\\n self.labels = np.array(labels, dtype=np.int32)\",\n \"def fit_satellite_centers(image, spotcenters_init, window=20):\\n # fit satellite centers\\n scs = np.zeros((len(spotcenters_init), 2))\\n for idx,xy in enumerate(spotcenters_init):\\n subim = pre.subimage(image, xy, window=window)\\n popt = snm.image_centroid_gaussian1(subim)\\n xcenp = popt[1]\\n ycenp = popt[2]\\n xcen = xy[0]-round(window/2)+xcenp\\n ycen = xy[1]-round(window/2)+ycenp\\n scs[idx,:] = xcen, ycen \\n \\n return scs\",\n \"def centroid(coords,masses,divider):\\n\\treturn np.array([np.dot(masses[r].T,coords[r])/np.sum(masses[r]) for r in divider])\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def xcenters(self):\\n return self.centers[0]\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def centers(self):\\n def make_centers(x):\\n return 0.25 * (x[:-1, :-1] + x[:-1, 1:] + x[1:, :-1] + x[1:, 1:])\\n\\n polar_centers = make_centers(self.polar_corners)\\n azimuthal_centers = make_centers(self.azimuthal_corners)\\n\\n assert azimuthal_centers.shape == polar_centers.shape\\n return polar_centers, azimuthal_centers\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def k_means_cc(self, X_columns, y_column, k, n_features=0):\\n try:\\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\\n \\n\\n fig = plt.figure(1)\\n fig.subplots_adjust(hspace=0.5)\\n for x in range(0,centroids.shape[1]):\\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\\n cmap = 'Set1'\\n for c in range(centroids.shape[0]):\\n temp_df = labeled_features[labeled_features['clusters'] == c]\\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\\n ax.set_xlabel(labeled_features.columns[x])\\n ax.axis('tight')\\n if(x == 0):\\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\\n plt.annotate(\\\"Silhouette Coefficient: \\\"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\\n plt.suptitle(\\\"Scatter Plot of \\\"+labeled_features.columns[0]+\\\" against other Features\\\")\\n \\n fig2 = plt.figure(2)\\n ax2 = fig2.subplots()\\n for k in range(centroids.shape[0]):\\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\\\": \\\"+str(centroids[k]))\\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\\n plt.xlabel(\\\"Features\\\")\\n plt.ylabel(\\\"Location\\\")\\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\\\"left\\\" )\\n plt.legend(loc=\\\"upper right\\\",title='Clusters (Centroids)')\\n plt.title(\\\"Centroid Chart (\\\"+y_column+\\\")\\\")\\n plt.tight_layout()\\n\\n plt.show()\\n\\n except Exception as e:\\n print(e)\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def _init_centroid(self, data):\\n\\n\\t\\tcentroids = data[:self._k]\\n\\t\\tx_assignee = data\\n\\n\\t\\treturn centroids, x_assignee\",\n \"def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\\n\\n if random_state is not None: np.random.seed(random_state)\\n\\n n_samples = n_samples//n_cluster\\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\\n\\n for cluster_idx in range(n_cluster):\\n # Group indicator\\n #group = sp.binom.rvs(p=0.25, n=1, size=N\\n n_neg = int(n_samples*(1-pos_ratio))\\n n_pos = n_samples-n_neg\\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\\n\\n idx_dependent = n_var - n_dependent\\n\\n if mean is None:\\n basic_mean = 0 #np.random.uniform(size=no_var)\\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n else:\\n mean0 = mean[cluster_idx][0]\\n mean1 = mean[cluster_idx][1]\\n \\n\\n # # Noise are variables with same distribution in majority and minority class\\n # if noise_ratio != 0:\\n # n_noise = int(noise_ratio*n_var)\\n # noise_idx = n_var - n_noise\\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\\n # size=n_samples).reshape([n_samples,-1])\\n \\n cov0, cov1 = None, None\\n\\n X1 = []\\n X0 = []\\n # Independent variables\\n if n_var-n_dependent > 0:\\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\\n\\n # Dependent variables\\n if n_dependent>0:\\n if cov is None:\\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n else:\\n cov0 = cov[cluster_idx][0]\\n cov1 = cov[cluster_idx][1]\\n\\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\\n cov= cov1, size=n_pos)\\n )\\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\\n cov= cov0, size=n_neg)\\n )\\n \\n X0 = np.hstack([*X0])\\n X1 = np.hstack([*X1])\\n X_cluster.append(np.vstack([X0, X1]))\\n #X = np.hstack([X, X_noise])\\n\\n mean0_cluster.append(mean0)\\n mean1_cluster.append(mean1)\\n cov0_cluster.append(cov0)\\n cov1_cluster.append(cov1)\\n\\n if n_cluster == 1:\\n X = X_cluster[0]\\n y = y_cluster[0]\\n else:\\n X = np.vstack(X_cluster)\\n y = np.hstack(y_cluster)\\n\\n #return {\\\"X\\\":X, \\\"y\\\":y,\\\"mean0\\\":mean0,\\\"mean1\\\":mean1, \\\"cov0\\\":cov0, \\\"cov1\\\":cov1}\\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster\",\n \"def __get_initial_centroid(self, x_train, seed=None):\\n if self.init == \\\"random\\\":\\n # randomly select n_cluster point from the input dataset\\n if seed:\\n random.seed(seed)\\n return np.asarray(random.choices(x_train, k=self.n_cluster))\",\n \"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\\n self.n = n\\n self.d = d\\n\\n # 95% of data lies in a 2*sigma ball around the mean.\\n # For unit variance normal, the 2*sigma ball mean the centers\\n # should be at distance of 4 in the d dimensional space.\\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\\n cov = np.eye(d)\\n\\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\\n # print(dist_mean)\\n # cov = np.eye(d)\\n\\n frac = int(1 / pos_fraction)\\n\\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\\n\\n self.X = np.vstack((cluster1, cluster2))\\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\\n\\n # Make blobs\\n # if True:\\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def compute_covar_from_instance_centroids(instance_centroids):\\n\\n cov_mat_allStructures = {}\\n radii_allStructures = {}\\n ellipsoid_matrix_allStructures = {}\\n for name_s, centroids in sorted(instance_centroids.items()):\\n centroids2 = np.array(centroids)\\n cov_mat = np.cov(centroids2.T)\\n cov_mat_allStructures[name_s] = cov_mat\\n u, s, vt = np.linalg.svd(cov_mat)\\n # print name_s, u[:,0], u[:,1], u[:,2],\\n radii_allStructures[name_s] = np.sqrt(s)\\n ellipsoid_matrix_allStructures[name_s] = vt\\n\\n return cov_mat_allStructures, radii_allStructures, ellipsoid_matrix_allStructures\",\n \"def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n\\n # Scale the data so that Euclidian distance makes sense\\n means = np.mean(data, axis = 0)\\n stddevs = np.std(data, axis = 0, ddof = 1)\\n\\n #print(means)\\n #print(stddevs)\\n\\n data_scaled = np.zeros((n_examples, n_features))\\n\\n for i in range(n_features):\\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\\n\\n study_correlation(data_scaled)\\n\\n # Initialize the centroids\\n idx = np.random.randint(n_examples, size = n_clusters)\\n centroids = data_scaled[idx, :]\\n\\n counter = 0\\n\\n while True:\\n\\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\\n centroid_idx = np.argmin(distances, axis = 1)\\n old_centroids = centroids\\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\\n #displacement = get_displacement(old_centroids, centroids)\\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\\n\\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\\n\\n if counter == 0:\\n# print(\\\"Initial displacement = {}\\\".format(displacement))\\n initial_displacement = displacement\\n\\n counter += 1\\n\\n if displacement < (initial_displacement / 10000): break\\n\\n #print(\\\"Total number of loops before ending : {}\\\".format(counter))\\n converted_predictions = convert_predictions(centroid_idx)\\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def initiateCentroid(data_points, centroids, k):\\n #Create empty list in list (amount is k)\\n AvgCentroids = [[] for i in range(k)]\\n\\n #For each datapoint in all datapoints\\n for dp in data_points:\\n dis = []\\n #For each centroid in centroids\\n for c in range(len(centroids)):\\n #Calculate the euclidean distance between those points and append\\n #to distance list\\n dis.append(calcEuclideanDistance(dp, centroids[c]))\\n \\n #Get the smallest value of the list and the index\\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\\n\\n #The index of the smallest value is the index where it will be added\\n #to the avgCentroids list. So it represents the number of the cluster\\n AvgCentroids[idx].append(dp)\\n \\n return AvgCentroids\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def get_viable_pos_cluster_centers(self, index, radius, cutoff, num_pts=None):\\n\\n viable_pos = self.get_viable_positions(index, radius, cutoff, num_pts)\\n ms = MeanShift(bin_seeding=True)\\n ms.fit(np.array(viable_pos))\\n cluster_centers = ms.cluster_centers_\\n return cluster_centers\",\n \"def calculate_cluster_center(self, threshold):\\n gamma = self.gamma\\n self.cluster_center = np.where(gamma >= threshold)[0]\",\n \"def __init__(self, init_centers):\\n\\n assert len(init_centers.shape) == 2, f\\\"init_centers should be a KxD matrix. Got: {init_centers.shape}\\\"\\n (self.K, self.D) = init_centers.shape\\n assert self.K > 1, f\\\"There must be at least 2 clusters. Got: {self.K}\\\"\\n\\n # Shape: K x D\\n self.centers = np.copy(init_centers)\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def plot_clusters(true_data, preds, cluster_center, cluster_name, savefig=\\\"\\\", title=\\\"\\\"):\\n\\n colors = plt.cm.get_cmap('hsv', len(cluster_name)+1) # get colors for each cluster using get_cmap. This will give us len(cluster_name) colors in a object form.\\n \\n for i, c in enumerate(cluster_name): # iterate through each cluster name\\n if c == -1: # -1 is given by DBScan for noise\\n clrs = 'grey' # make it grey\\n label = 'Noise' # label it 'Noise'\\n else:\\n clrs = colors(c) # get color for it\\n label=f'Cluster {c}' # label it by its name\\n df = true_data[preds == c] # get the points from dataset whose prediction was cluster `c`\\n x, y = df.iloc[:, 0], df.iloc[:, 1] # x and y axis\\n plt.scatter( # plotting the x and y axis\\n x, y,\\n label=label,\\n color=clrs\\n )\\n if c != -1:\\n plt.text(\\n cluster_center[i][0] + 0.03, cluster_center[i][1] + 0.1,\\n f\\\"Cluster {i}\\\",\\n weight='bold',\\n fontsize=9,\\n )\\n \\n plt.scatter(\\n cluster_center[:, 0], cluster_center[:, 1], # plotting the cluster centers\\n s=250, marker='*',\\n c='red', edgecolor='black',\\n label='Centroids'\\n )\\n \\n plt.title(title)\\n plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\\n plt.tight_layout()\\n if savefig != \\\"\\\" : plt.savefig(f\\\"{savefig}.png\\\")\\n plt.show()\\n plt.close()\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def centroid(sign, FS):\\n\\n time = compute_time(sign, FS)\\n\\n energy, time_energy=signal_energy(sign, time)\\n\\n total_energy = np.dot(np.array(time_energy),np.array(energy))\\n energy_sum = np.sum(energy)\\n\\n if energy_sum == 0 or total_energy == 0:\\n centroid = 0\\n else:\\n centroid = total_energy / energy_sum\\n return centroid\",\n \"def calcCentroid(self):\\n size = len(self.vectors)\\n # zip all features together\\n zipped = zip(*self.vectors)\\n # Calculate the mean for each feature/column\\n centroid = [math.fsum(column)/size for column in zipped]\\n \\n return centroid\",\n \"def __cmeans(self, points, nclusters):\\n # load list of points for cluster analysis\\n # initialize\\n initial_centers = kmeans_plusplus_initializer(points, nclusters, kmeans_plusplus_initializer.FARTHEST_CENTER_CANDIDATE).initialize()\\n # create instance of Fuzzy C-Means algorithm\\n fcm_instance = fcm(points, initial_centers)\\n # run cluster analysis and obtain results\\n fcm_instance.process()\\n clusters = fcm_instance.get_clusters()\\n centers = fcm_instance.get_centers()\\n membership = fcm_instance.get_membership()\\n return clusters, centers, membership\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def assign_centroids(data, centroids) :\\r\\n distances = []\\r\\n for centroid in centroids :\\r\\n distances.append(np.linalg.norm(data - centroid, axis=1))\\r\\n distances = np.column_stack(distances)\\r\\n assigned_centroids = np.argmin(distances, axis=1).flatten()\\r\\n return assigned_centroids\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6637167","0.6619889","0.64092225","0.6370468","0.6316697","0.6288295","0.6286796","0.6268664","0.6214184","0.61212265","0.6098709","0.60670376","0.60576606","0.6025386","0.6019331","0.60053873","0.59957886","0.5989434","0.5931372","0.5907089","0.59067917","0.59026355","0.5888721","0.58854955","0.58854955","0.5880567","0.58751595","0.5860803","0.58597356","0.5824667","0.5821488","0.5805261","0.580129","0.5797546","0.5787889","0.5780225","0.57778823","0.5771121","0.57655597","0.5756722","0.57475483","0.57318527","0.57304156","0.571658","0.5705025","0.57038915","0.5703352","0.56916773","0.5684386","0.5675104","0.56690323","0.5660189","0.5656921","0.56468445","0.56446576","0.56348306","0.5633911","0.5624651","0.56224376","0.55967736","0.55921763","0.5584659","0.55837727","0.55796987","0.5579215","0.5575476","0.55660015","0.5563586","0.55558366","0.55513483","0.55465263","0.5544339","0.55267334","0.55222464","0.5520528","0.552044","0.55193305","0.55060273","0.5505803","0.55041766","0.54892236","0.5476948","0.54768676","0.5465354","0.54547334","0.54517627","0.5451034","0.54450476","0.5443578","0.5440092","0.5433518","0.5429913","0.54293185","0.5429289","0.54274756","0.54265237","0.5424071","0.5418566","0.5412262","0.5407552","0.53978664"],"string":"[\n \"0.6637167\",\n \"0.6619889\",\n \"0.64092225\",\n \"0.6370468\",\n \"0.6316697\",\n \"0.6288295\",\n \"0.6286796\",\n \"0.6268664\",\n \"0.6214184\",\n \"0.61212265\",\n \"0.6098709\",\n \"0.60670376\",\n \"0.60576606\",\n \"0.6025386\",\n \"0.6019331\",\n \"0.60053873\",\n \"0.59957886\",\n \"0.5989434\",\n \"0.5931372\",\n \"0.5907089\",\n \"0.59067917\",\n \"0.59026355\",\n \"0.5888721\",\n \"0.58854955\",\n \"0.58854955\",\n \"0.5880567\",\n \"0.58751595\",\n \"0.5860803\",\n \"0.58597356\",\n \"0.5824667\",\n \"0.5821488\",\n \"0.5805261\",\n \"0.580129\",\n \"0.5797546\",\n \"0.5787889\",\n \"0.5780225\",\n \"0.57778823\",\n \"0.5771121\",\n \"0.57655597\",\n \"0.5756722\",\n \"0.57475483\",\n \"0.57318527\",\n \"0.57304156\",\n \"0.571658\",\n \"0.5705025\",\n \"0.57038915\",\n \"0.5703352\",\n \"0.56916773\",\n \"0.5684386\",\n \"0.5675104\",\n \"0.56690323\",\n \"0.5660189\",\n \"0.5656921\",\n \"0.56468445\",\n \"0.56446576\",\n \"0.56348306\",\n \"0.5633911\",\n \"0.5624651\",\n \"0.56224376\",\n \"0.55967736\",\n \"0.55921763\",\n \"0.5584659\",\n \"0.55837727\",\n \"0.55796987\",\n \"0.5579215\",\n \"0.5575476\",\n \"0.55660015\",\n \"0.5563586\",\n \"0.55558366\",\n \"0.55513483\",\n \"0.55465263\",\n \"0.5544339\",\n \"0.55267334\",\n \"0.55222464\",\n \"0.5520528\",\n \"0.552044\",\n \"0.55193305\",\n \"0.55060273\",\n \"0.5505803\",\n \"0.55041766\",\n \"0.54892236\",\n \"0.5476948\",\n \"0.54768676\",\n \"0.5465354\",\n \"0.54547334\",\n \"0.54517627\",\n \"0.5451034\",\n \"0.54450476\",\n \"0.5443578\",\n \"0.5440092\",\n \"0.5433518\",\n \"0.5429913\",\n \"0.54293185\",\n \"0.5429289\",\n \"0.54274756\",\n \"0.54265237\",\n \"0.5424071\",\n \"0.5418566\",\n \"0.5412262\",\n \"0.5407552\",\n \"0.53978664\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9486,"cells":{"query":{"kind":"string","value":"Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]"},"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 _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def elbow(self, nrange=(2,9)):\n\n inertias = []\n for N in xrange(*nrange):\n km = KMeans(n_clusters = N)\n km.fit(self.data.values)\n inertias.append(km.inertia_)\n\n print inertias\n plt.plot(range(*nrange), inertias, marker=\"o\", markerfacecolor=\"purple\")\n plt.title(\"cluster elbow\")\n plt.ylabel(\"KMeans inertia\")\n plt.xlabel(\"n_clusters\")\n\n return plt","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def atlas_clusters():\n pass","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def centers(self):\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)","def k_means_cc(self, X_columns, y_column, k, n_features=0):\n try:\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\n \n\n fig = plt.figure(1)\n fig.subplots_adjust(hspace=0.5)\n for x in range(0,centroids.shape[1]):\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\n cmap = 'Set1'\n for c in range(centroids.shape[0]):\n temp_df = labeled_features[labeled_features['clusters'] == c]\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\n ax.set_xlabel(labeled_features.columns[x])\n ax.axis('tight')\n if(x == 0):\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\n plt.annotate(\"Silhouette Coefficient: \"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\n plt.suptitle(\"Scatter Plot of \"+labeled_features.columns[0]+\" against other Features\")\n \n fig2 = plt.figure(2)\n ax2 = fig2.subplots()\n for k in range(centroids.shape[0]):\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\": \"+str(centroids[k]))\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\n plt.xlabel(\"Features\")\n plt.ylabel(\"Location\")\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\"left\" )\n plt.legend(loc=\"upper right\",title='Clusters (Centroids)')\n plt.title(\"Centroid Chart (\"+y_column+\")\")\n plt.tight_layout()\n\n plt.show()\n\n except Exception as e:\n print(e)","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def kmeans_cluster(X_train_input, n_clusters=100):\r\n from sklearn.cluster import MiniBatchKMeans\r\n image_descriptors = []\r\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\r\n image_descriptors = np.array(image_descriptors) \r\n \r\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\r\n random_state=34, batch_size=128).fit(image_descriptors)\r\n \r\n return kmeans_model","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def recenter(self, n):\n clustering = self\n for i in xrange(n):\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\n consensus_threshold=clustering.consensus_threshold)\n return clustering","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def customNcuts(self):\n # computing neighboors graph\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\n\n for i in range(self.values.shape[0]):\n for j in range(self.values.shape[0]):\n if A[i][j] > 0:\n\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\n\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\n\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\n\n # init SpectralClustering\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\n\n # cluster\n labels = sc.fit_predict(A)\n\n return labels","def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\n # Randomly pick 5 boxes as centroids\n centroids = np.array(random.sample(boxes, k=num_anchors))\n # Clustering until reaching loss_convergence threshold\n centroids, prev_errors = k_mean(boxes, centroids)\n while True:\n centroids, errors = k_mean(boxes, centroids)\n if abs(errors - prev_errors) <= convergence_threshold:\n break\n else:\n prev_errors = errors\n\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\n return centroids, avg_iou","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion"],"string":"[\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def elbow(self, nrange=(2,9)):\\n\\n inertias = []\\n for N in xrange(*nrange):\\n km = KMeans(n_clusters = N)\\n km.fit(self.data.values)\\n inertias.append(km.inertia_)\\n\\n print inertias\\n plt.plot(range(*nrange), inertias, marker=\\\"o\\\", markerfacecolor=\\\"purple\\\")\\n plt.title(\\\"cluster elbow\\\")\\n plt.ylabel(\\\"KMeans inertia\\\")\\n plt.xlabel(\\\"n_clusters\\\")\\n\\n return plt\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def atlas_clusters():\\n pass\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def centers(self):\\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)\",\n \"def k_means_cc(self, X_columns, y_column, k, n_features=0):\\n try:\\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\\n \\n\\n fig = plt.figure(1)\\n fig.subplots_adjust(hspace=0.5)\\n for x in range(0,centroids.shape[1]):\\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\\n cmap = 'Set1'\\n for c in range(centroids.shape[0]):\\n temp_df = labeled_features[labeled_features['clusters'] == c]\\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\\n ax.set_xlabel(labeled_features.columns[x])\\n ax.axis('tight')\\n if(x == 0):\\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\\n plt.annotate(\\\"Silhouette Coefficient: \\\"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\\n plt.suptitle(\\\"Scatter Plot of \\\"+labeled_features.columns[0]+\\\" against other Features\\\")\\n \\n fig2 = plt.figure(2)\\n ax2 = fig2.subplots()\\n for k in range(centroids.shape[0]):\\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\\\": \\\"+str(centroids[k]))\\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\\n plt.xlabel(\\\"Features\\\")\\n plt.ylabel(\\\"Location\\\")\\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\\\"left\\\" )\\n plt.legend(loc=\\\"upper right\\\",title='Clusters (Centroids)')\\n plt.title(\\\"Centroid Chart (\\\"+y_column+\\\")\\\")\\n plt.tight_layout()\\n\\n plt.show()\\n\\n except Exception as e:\\n print(e)\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def kmeans_cluster(X_train_input, n_clusters=100):\\r\\n from sklearn.cluster import MiniBatchKMeans\\r\\n image_descriptors = []\\r\\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\\r\\n image_descriptors = np.array(image_descriptors) \\r\\n \\r\\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\\r\\n random_state=34, batch_size=128).fit(image_descriptors)\\r\\n \\r\\n return kmeans_model\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def recenter(self, n):\\n clustering = self\\n for i in xrange(n):\\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\\n consensus_threshold=clustering.consensus_threshold)\\n return clustering\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def customNcuts(self):\\n # computing neighboors graph\\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\\n\\n for i in range(self.values.shape[0]):\\n for j in range(self.values.shape[0]):\\n if A[i][j] > 0:\\n\\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\\n\\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\\n\\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\\n\\n # init SpectralClustering\\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\\n\\n # cluster\\n labels = sc.fit_predict(A)\\n\\n return labels\",\n \"def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\\n # Randomly pick 5 boxes as centroids\\n centroids = np.array(random.sample(boxes, k=num_anchors))\\n # Clustering until reaching loss_convergence threshold\\n centroids, prev_errors = k_mean(boxes, centroids)\\n while True:\\n centroids, errors = k_mean(boxes, centroids)\\n if abs(errors - prev_errors) <= convergence_threshold:\\n break\\n else:\\n prev_errors = errors\\n\\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\\n return centroids, avg_iou\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76212066","0.7217054","0.71860254","0.69142705","0.68518704","0.68461156","0.66278195","0.66259587","0.6578559","0.63746804","0.63681006","0.63251126","0.6259267","0.62513924","0.6211149","0.62032765","0.61599225","0.6159027","0.6151934","0.6151934","0.60959435","0.6091121","0.60782045","0.6071997","0.6064495","0.6054118","0.60459524","0.6036025","0.603172","0.6025404","0.60050654","0.59962565","0.59879273","0.5962929","0.59488356","0.5948024","0.5947616","0.59404844","0.59372956","0.5912713","0.5907477","0.5886835","0.58483815","0.58169645","0.5790071","0.57883793","0.5784537","0.5777603","0.57745636","0.57655513","0.575513","0.5745229","0.5741054","0.57373005","0.5733041","0.57329583","0.5732483","0.57229614","0.57023156","0.5696992","0.5691173","0.56890404","0.56873345","0.567804","0.56461406","0.56309336","0.5626847","0.5623201","0.5622737","0.5613893","0.5605625","0.56045824","0.56020296","0.5599616","0.5595023","0.55709827","0.55579555","0.55458605","0.5545231","0.55435055","0.5527012","0.5522461","0.55218786","0.5518487","0.55168134","0.55131644","0.5499563","0.5492497","0.5490711","0.54890084","0.5486725","0.5483188","0.54825795","0.54707366","0.54704255","0.54634273","0.5458666","0.5456244","0.5455224","0.544696"],"string":"[\n \"0.76212066\",\n \"0.7217054\",\n \"0.71860254\",\n \"0.69142705\",\n \"0.68518704\",\n \"0.68461156\",\n \"0.66278195\",\n \"0.66259587\",\n \"0.6578559\",\n \"0.63746804\",\n \"0.63681006\",\n \"0.63251126\",\n \"0.6259267\",\n \"0.62513924\",\n \"0.6211149\",\n \"0.62032765\",\n \"0.61599225\",\n \"0.6159027\",\n \"0.6151934\",\n \"0.6151934\",\n \"0.60959435\",\n \"0.6091121\",\n \"0.60782045\",\n \"0.6071997\",\n \"0.6064495\",\n \"0.6054118\",\n \"0.60459524\",\n \"0.6036025\",\n \"0.603172\",\n \"0.6025404\",\n \"0.60050654\",\n \"0.59962565\",\n \"0.59879273\",\n \"0.5962929\",\n \"0.59488356\",\n \"0.5948024\",\n \"0.5947616\",\n \"0.59404844\",\n \"0.59372956\",\n \"0.5912713\",\n \"0.5907477\",\n \"0.5886835\",\n \"0.58483815\",\n \"0.58169645\",\n \"0.5790071\",\n \"0.57883793\",\n \"0.5784537\",\n \"0.5777603\",\n \"0.57745636\",\n \"0.57655513\",\n \"0.575513\",\n \"0.5745229\",\n \"0.5741054\",\n \"0.57373005\",\n \"0.5733041\",\n \"0.57329583\",\n \"0.5732483\",\n \"0.57229614\",\n \"0.57023156\",\n \"0.5696992\",\n \"0.5691173\",\n \"0.56890404\",\n \"0.56873345\",\n \"0.567804\",\n \"0.56461406\",\n \"0.56309336\",\n \"0.5626847\",\n \"0.5623201\",\n \"0.5622737\",\n \"0.5613893\",\n \"0.5605625\",\n \"0.56045824\",\n \"0.56020296\",\n \"0.5599616\",\n \"0.5595023\",\n \"0.55709827\",\n \"0.55579555\",\n \"0.55458605\",\n \"0.5545231\",\n \"0.55435055\",\n \"0.5527012\",\n \"0.5522461\",\n \"0.55218786\",\n \"0.5518487\",\n \"0.55168134\",\n \"0.55131644\",\n \"0.5499563\",\n \"0.5492497\",\n \"0.5490711\",\n \"0.54890084\",\n \"0.5486725\",\n \"0.5483188\",\n \"0.54825795\",\n \"0.54707366\",\n \"0.54704255\",\n \"0.54634273\",\n \"0.5458666\",\n \"0.5456244\",\n \"0.5455224\",\n \"0.544696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8075378"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9487,"cells":{"query":{"kind":"string","value":"Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def elbow(self, nrange=(2,9)):\n\n inertias = []\n for N in xrange(*nrange):\n km = KMeans(n_clusters = N)\n km.fit(self.data.values)\n inertias.append(km.inertia_)\n\n print inertias\n plt.plot(range(*nrange), inertias, marker=\"o\", markerfacecolor=\"purple\")\n plt.title(\"cluster elbow\")\n plt.ylabel(\"KMeans inertia\")\n plt.xlabel(\"n_clusters\")\n\n return plt","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def atlas_clusters():\n pass","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def centers(self):\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)","def k_means_cc(self, X_columns, y_column, k, n_features=0):\n try:\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\n \n\n fig = plt.figure(1)\n fig.subplots_adjust(hspace=0.5)\n for x in range(0,centroids.shape[1]):\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\n cmap = 'Set1'\n for c in range(centroids.shape[0]):\n temp_df = labeled_features[labeled_features['clusters'] == c]\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\n ax.set_xlabel(labeled_features.columns[x])\n ax.axis('tight')\n if(x == 0):\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\n plt.annotate(\"Silhouette Coefficient: \"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\n plt.suptitle(\"Scatter Plot of \"+labeled_features.columns[0]+\" against other Features\")\n \n fig2 = plt.figure(2)\n ax2 = fig2.subplots()\n for k in range(centroids.shape[0]):\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\": \"+str(centroids[k]))\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\n plt.xlabel(\"Features\")\n plt.ylabel(\"Location\")\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\"left\" )\n plt.legend(loc=\"upper right\",title='Clusters (Centroids)')\n plt.title(\"Centroid Chart (\"+y_column+\")\")\n plt.tight_layout()\n\n plt.show()\n\n except Exception as e:\n print(e)","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def kmeans_cluster(X_train_input, n_clusters=100):\r\n from sklearn.cluster import MiniBatchKMeans\r\n image_descriptors = []\r\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\r\n image_descriptors = np.array(image_descriptors) \r\n \r\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\r\n random_state=34, batch_size=128).fit(image_descriptors)\r\n \r\n return kmeans_model","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def recenter(self, n):\n clustering = self\n for i in xrange(n):\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\n consensus_threshold=clustering.consensus_threshold)\n return clustering","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def customNcuts(self):\n # computing neighboors graph\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\n\n for i in range(self.values.shape[0]):\n for j in range(self.values.shape[0]):\n if A[i][j] > 0:\n\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\n\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\n\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\n\n # init SpectralClustering\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\n\n # cluster\n labels = sc.fit_predict(A)\n\n return labels","def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\n # Randomly pick 5 boxes as centroids\n centroids = np.array(random.sample(boxes, k=num_anchors))\n # Clustering until reaching loss_convergence threshold\n centroids, prev_errors = k_mean(boxes, centroids)\n while True:\n centroids, errors = k_mean(boxes, centroids)\n if abs(errors - prev_errors) <= convergence_threshold:\n break\n else:\n prev_errors = errors\n\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\n return centroids, avg_iou","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def clusterGen(k, colors):\n clusters = []\n # generate the clusters randomly\n # for i in range(k):\n # r = random.randint(0, 255)\n # g = random.randint(0, 255)\n # b = random.randint(0, 255)\n # clusters.append((r, g, b))\n\n # generate the clusters that exist in colors\n l = len(colors)\n for i in range(k):\n r = random.randint(0, l)\n cluster = colors[r][1]\n clusters.append(cluster)\n\n return clusters"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def elbow(self, nrange=(2,9)):\\n\\n inertias = []\\n for N in xrange(*nrange):\\n km = KMeans(n_clusters = N)\\n km.fit(self.data.values)\\n inertias.append(km.inertia_)\\n\\n print inertias\\n plt.plot(range(*nrange), inertias, marker=\\\"o\\\", markerfacecolor=\\\"purple\\\")\\n plt.title(\\\"cluster elbow\\\")\\n plt.ylabel(\\\"KMeans inertia\\\")\\n plt.xlabel(\\\"n_clusters\\\")\\n\\n return plt\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def atlas_clusters():\\n pass\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def centers(self):\\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)\",\n \"def k_means_cc(self, X_columns, y_column, k, n_features=0):\\n try:\\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\\n \\n\\n fig = plt.figure(1)\\n fig.subplots_adjust(hspace=0.5)\\n for x in range(0,centroids.shape[1]):\\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\\n cmap = 'Set1'\\n for c in range(centroids.shape[0]):\\n temp_df = labeled_features[labeled_features['clusters'] == c]\\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\\n ax.set_xlabel(labeled_features.columns[x])\\n ax.axis('tight')\\n if(x == 0):\\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\\n plt.annotate(\\\"Silhouette Coefficient: \\\"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\\n plt.suptitle(\\\"Scatter Plot of \\\"+labeled_features.columns[0]+\\\" against other Features\\\")\\n \\n fig2 = plt.figure(2)\\n ax2 = fig2.subplots()\\n for k in range(centroids.shape[0]):\\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\\\": \\\"+str(centroids[k]))\\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\\n plt.xlabel(\\\"Features\\\")\\n plt.ylabel(\\\"Location\\\")\\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\\\"left\\\" )\\n plt.legend(loc=\\\"upper right\\\",title='Clusters (Centroids)')\\n plt.title(\\\"Centroid Chart (\\\"+y_column+\\\")\\\")\\n plt.tight_layout()\\n\\n plt.show()\\n\\n except Exception as e:\\n print(e)\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def kmeans_cluster(X_train_input, n_clusters=100):\\r\\n from sklearn.cluster import MiniBatchKMeans\\r\\n image_descriptors = []\\r\\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\\r\\n image_descriptors = np.array(image_descriptors) \\r\\n \\r\\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\\r\\n random_state=34, batch_size=128).fit(image_descriptors)\\r\\n \\r\\n return kmeans_model\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def recenter(self, n):\\n clustering = self\\n for i in xrange(n):\\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\\n consensus_threshold=clustering.consensus_threshold)\\n return clustering\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def customNcuts(self):\\n # computing neighboors graph\\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\\n\\n for i in range(self.values.shape[0]):\\n for j in range(self.values.shape[0]):\\n if A[i][j] > 0:\\n\\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\\n\\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\\n\\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\\n\\n # init SpectralClustering\\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\\n\\n # cluster\\n labels = sc.fit_predict(A)\\n\\n return labels\",\n \"def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\\n # Randomly pick 5 boxes as centroids\\n centroids = np.array(random.sample(boxes, k=num_anchors))\\n # Clustering until reaching loss_convergence threshold\\n centroids, prev_errors = k_mean(boxes, centroids)\\n while True:\\n centroids, errors = k_mean(boxes, centroids)\\n if abs(errors - prev_errors) <= convergence_threshold:\\n break\\n else:\\n prev_errors = errors\\n\\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\\n return centroids, avg_iou\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def clusterGen(k, colors):\\n clusters = []\\n # generate the clusters randomly\\n # for i in range(k):\\n # r = random.randint(0, 255)\\n # g = random.randint(0, 255)\\n # b = random.randint(0, 255)\\n # clusters.append((r, g, b))\\n\\n # generate the clusters that exist in colors\\n l = len(colors)\\n for i in range(k):\\n r = random.randint(0, l)\\n cluster = colors[r][1]\\n clusters.append(cluster)\\n\\n return clusters\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8075657","0.7216367","0.7186302","0.691356","0.68508494","0.6845249","0.66261995","0.6625447","0.6577691","0.6374363","0.63676125","0.6322932","0.625821","0.6250707","0.6211498","0.6203698","0.6160035","0.6157637","0.6151316","0.6151316","0.6094953","0.609167","0.6078563","0.6072399","0.60630804","0.60531735","0.60448426","0.6035322","0.60305756","0.60231733","0.60047364","0.5994528","0.5985369","0.59615874","0.59471303","0.5946632","0.59464914","0.594023","0.5935281","0.5911489","0.5905953","0.5885378","0.584858","0.5816084","0.5788799","0.5787915","0.5782121","0.5777319","0.57729226","0.5763848","0.57553965","0.57449377","0.5739268","0.57352966","0.5731682","0.5731248","0.57312167","0.5721075","0.57009614","0.5698216","0.5690398","0.56864876","0.56860256","0.5677518","0.56456244","0.56292295","0.56260616","0.56232905","0.56210047","0.56122327","0.5605474","0.5603851","0.5601479","0.5598708","0.5593195","0.55702233","0.5557309","0.55440545","0.55439746","0.55426764","0.5525779","0.5521414","0.5521052","0.55180556","0.5515163","0.55133945","0.54984146","0.5492007","0.54897565","0.54881895","0.54854554","0.548203","0.54814065","0.54702806","0.5469869","0.54616255","0.54582185","0.5455582","0.54529786","0.5446491"],"string":"[\n \"0.8075657\",\n \"0.7216367\",\n \"0.7186302\",\n \"0.691356\",\n \"0.68508494\",\n \"0.6845249\",\n \"0.66261995\",\n \"0.6625447\",\n \"0.6577691\",\n \"0.6374363\",\n \"0.63676125\",\n \"0.6322932\",\n \"0.625821\",\n \"0.6250707\",\n \"0.6211498\",\n \"0.6203698\",\n \"0.6160035\",\n \"0.6157637\",\n \"0.6151316\",\n \"0.6151316\",\n \"0.6094953\",\n \"0.609167\",\n \"0.6078563\",\n \"0.6072399\",\n \"0.60630804\",\n \"0.60531735\",\n \"0.60448426\",\n \"0.6035322\",\n \"0.60305756\",\n \"0.60231733\",\n \"0.60047364\",\n \"0.5994528\",\n \"0.5985369\",\n \"0.59615874\",\n \"0.59471303\",\n \"0.5946632\",\n \"0.59464914\",\n \"0.594023\",\n \"0.5935281\",\n \"0.5911489\",\n \"0.5905953\",\n \"0.5885378\",\n \"0.584858\",\n \"0.5816084\",\n \"0.5788799\",\n \"0.5787915\",\n \"0.5782121\",\n \"0.5777319\",\n \"0.57729226\",\n \"0.5763848\",\n \"0.57553965\",\n \"0.57449377\",\n \"0.5739268\",\n \"0.57352966\",\n \"0.5731682\",\n \"0.5731248\",\n \"0.57312167\",\n \"0.5721075\",\n \"0.57009614\",\n \"0.5698216\",\n \"0.5690398\",\n \"0.56864876\",\n \"0.56860256\",\n \"0.5677518\",\n \"0.56456244\",\n \"0.56292295\",\n \"0.56260616\",\n \"0.56232905\",\n \"0.56210047\",\n \"0.56122327\",\n \"0.5605474\",\n \"0.5603851\",\n \"0.5601479\",\n \"0.5598708\",\n \"0.5593195\",\n \"0.55702233\",\n \"0.5557309\",\n \"0.55440545\",\n \"0.55439746\",\n \"0.55426764\",\n \"0.5525779\",\n \"0.5521414\",\n \"0.5521052\",\n \"0.55180556\",\n \"0.5515163\",\n \"0.55133945\",\n \"0.54984146\",\n \"0.5492007\",\n \"0.54897565\",\n \"0.54881895\",\n \"0.54854554\",\n \"0.548203\",\n \"0.54814065\",\n \"0.54702806\",\n \"0.5469869\",\n \"0.54616255\",\n \"0.54582185\",\n \"0.5455582\",\n \"0.54529786\",\n \"0.5446491\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.762155"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":9488,"cells":{"query":{"kind":"string","value":"Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def elbow(self, nrange=(2,9)):\n\n inertias = []\n for N in xrange(*nrange):\n km = KMeans(n_clusters = N)\n km.fit(self.data.values)\n inertias.append(km.inertia_)\n\n print inertias\n plt.plot(range(*nrange), inertias, marker=\"o\", markerfacecolor=\"purple\")\n plt.title(\"cluster elbow\")\n plt.ylabel(\"KMeans inertia\")\n plt.xlabel(\"n_clusters\")\n\n return plt","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def atlas_clusters():\n pass","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def k_means_cc(self, X_columns, y_column, k, n_features=0):\n try:\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\n \n\n fig = plt.figure(1)\n fig.subplots_adjust(hspace=0.5)\n for x in range(0,centroids.shape[1]):\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\n cmap = 'Set1'\n for c in range(centroids.shape[0]):\n temp_df = labeled_features[labeled_features['clusters'] == c]\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\n ax.set_xlabel(labeled_features.columns[x])\n ax.axis('tight')\n if(x == 0):\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\n plt.annotate(\"Silhouette Coefficient: \"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\n plt.suptitle(\"Scatter Plot of \"+labeled_features.columns[0]+\" against other Features\")\n \n fig2 = plt.figure(2)\n ax2 = fig2.subplots()\n for k in range(centroids.shape[0]):\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\": \"+str(centroids[k]))\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\n plt.xlabel(\"Features\")\n plt.ylabel(\"Location\")\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\"left\" )\n plt.legend(loc=\"upper right\",title='Clusters (Centroids)')\n plt.title(\"Centroid Chart (\"+y_column+\")\")\n plt.tight_layout()\n\n plt.show()\n\n except Exception as e:\n print(e)","def centers(self):\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def kmeans_cluster(X_train_input, n_clusters=100):\r\n from sklearn.cluster import MiniBatchKMeans\r\n image_descriptors = []\r\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\r\n image_descriptors = np.array(image_descriptors) \r\n \r\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\r\n random_state=34, batch_size=128).fit(image_descriptors)\r\n \r\n return kmeans_model","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def recenter(self, n):\n clustering = self\n for i in xrange(n):\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\n consensus_threshold=clustering.consensus_threshold)\n return clustering","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def customNcuts(self):\n # computing neighboors graph\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\n\n for i in range(self.values.shape[0]):\n for j in range(self.values.shape[0]):\n if A[i][j] > 0:\n\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\n\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\n\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\n\n # init SpectralClustering\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\n\n # cluster\n labels = sc.fit_predict(A)\n\n return labels","def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\n # Randomly pick 5 boxes as centroids\n centroids = np.array(random.sample(boxes, k=num_anchors))\n # Clustering until reaching loss_convergence threshold\n centroids, prev_errors = k_mean(boxes, centroids)\n while True:\n centroids, errors = k_mean(boxes, centroids)\n if abs(errors - prev_errors) <= convergence_threshold:\n break\n else:\n prev_errors = errors\n\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\n return centroids, avg_iou","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def elbow(self, nrange=(2,9)):\\n\\n inertias = []\\n for N in xrange(*nrange):\\n km = KMeans(n_clusters = N)\\n km.fit(self.data.values)\\n inertias.append(km.inertia_)\\n\\n print inertias\\n plt.plot(range(*nrange), inertias, marker=\\\"o\\\", markerfacecolor=\\\"purple\\\")\\n plt.title(\\\"cluster elbow\\\")\\n plt.ylabel(\\\"KMeans inertia\\\")\\n plt.xlabel(\\\"n_clusters\\\")\\n\\n return plt\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def atlas_clusters():\\n pass\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def k_means_cc(self, X_columns, y_column, k, n_features=0):\\n try:\\n centroids, sil_coef,labeled_features = self.k_means(X_columns, y_column, k, n_features=n_features)\\n \\n\\n fig = plt.figure(1)\\n fig.subplots_adjust(hspace=0.5)\\n for x in range(0,centroids.shape[1]):\\n ax = fig.add_subplot(round(centroids.shape[1]/2), 2, x+1)\\n cmap = 'Set1'\\n for c in range(centroids.shape[0]):\\n temp_df = labeled_features[labeled_features['clusters'] == c]\\n ax.scatter(temp_df[labeled_features.columns[x]], temp_df[labeled_features.columns[0]], label=c, cmap=cmap[c])\\n ax.set_xlabel(labeled_features.columns[x])\\n ax.axis('tight')\\n if(x == 0):\\n plt.legend(title='Clusters', loc='upper right',bbox_to_anchor=(-0.1, 1.1))\\n fig.text(0.04, 0.5, labeled_features.columns[0], va='center', rotation='vertical')\\n plt.annotate(\\\"Silhouette Coefficient: \\\"+ str(sil_coef),xy=(10, 10), xycoords='figure pixels')\\n plt.suptitle(\\\"Scatter Plot of \\\"+labeled_features.columns[0]+\\\" against other Features\\\")\\n \\n fig2 = plt.figure(2)\\n ax2 = fig2.subplots()\\n for k in range(centroids.shape[0]):\\n plt.plot(range(centroids.shape[1]),centroids[k], label=str(k)+\\\": \\\"+str(centroids[k]))\\n plt.xticks(range(centroids.shape[1]),labeled_features.columns[:-1])\\n plt.xlabel(\\\"Features\\\")\\n plt.ylabel(\\\"Location\\\")\\n plt.setp( ax2.xaxis.get_majorticklabels(), rotation=-15, ha=\\\"left\\\" )\\n plt.legend(loc=\\\"upper right\\\",title='Clusters (Centroids)')\\n plt.title(\\\"Centroid Chart (\\\"+y_column+\\\")\\\")\\n plt.tight_layout()\\n\\n plt.show()\\n\\n except Exception as e:\\n print(e)\",\n \"def centers(self):\\n return tuple(0.5 * (e[1:] + e[:-1]) for e in self.edges)\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def kmeans_cluster(X_train_input, n_clusters=100):\\r\\n from sklearn.cluster import MiniBatchKMeans\\r\\n image_descriptors = []\\r\\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\\r\\n image_descriptors = np.array(image_descriptors) \\r\\n \\r\\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\\r\\n random_state=34, batch_size=128).fit(image_descriptors)\\r\\n \\r\\n return kmeans_model\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def recenter(self, n):\\n clustering = self\\n for i in xrange(n):\\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\\n consensus_threshold=clustering.consensus_threshold)\\n return clustering\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def customNcuts(self):\\n # computing neighboors graph\\n A = kneighbors_graph(self.values, self.k, mode='distance', include_self=False).toarray()\\n\\n for i in range(self.values.shape[0]):\\n for j in range(self.values.shape[0]):\\n if A[i][j] > 0:\\n\\n v1 = (self.values[i][3], self.values[i][4], self.values[i][5])\\n v2 = (self.values[j][3], self.values[j][4], self.values[j][5])\\n\\n magnitude1 = np.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2])\\n magnitude2 = np.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2])\\n ang = np.arccos(np.dot(v1, v2) / (magnitude1 * magnitude2))\\n\\n A[i][j] = max(self.values[i][7], self.values[j][7]) * A[i][j]\\n\\n # init SpectralClustering\\n sc = SpectralClustering(4, affinity='precomputed', n_init=10, assign_labels = 'discretize')\\n\\n # cluster\\n labels = sc.fit_predict(A)\\n\\n return labels\",\n \"def k_mean_cluster(num_anchors, boxes, convergence_threshold=1e-9):\\n # Randomly pick 5 boxes as centroids\\n centroids = np.array(random.sample(boxes, k=num_anchors))\\n # Clustering until reaching loss_convergence threshold\\n centroids, prev_errors = k_mean(boxes, centroids)\\n while True:\\n centroids, errors = k_mean(boxes, centroids)\\n if abs(errors - prev_errors) <= convergence_threshold:\\n break\\n else:\\n prev_errors = errors\\n\\n avg_iou = np.mean(np.max(compute_iou(boxes, centroids), axis=-1))\\n return centroids, avg_iou\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80750877","0.7620803","0.72162825","0.69135714","0.6852057","0.6845415","0.66279685","0.6627276","0.65779185","0.6375827","0.6368961","0.6324704","0.62609804","0.62517524","0.6210675","0.6203783","0.6160406","0.61593336","0.6152343","0.6152343","0.6096672","0.6093078","0.60796815","0.6072978","0.60647315","0.6053542","0.6046819","0.6037067","0.60321033","0.60260093","0.6006326","0.5996785","0.5988853","0.59621197","0.5949978","0.59483516","0.5947163","0.59412795","0.593777","0.5913194","0.59083414","0.5886624","0.5849588","0.5817861","0.5790656","0.57889646","0.5783504","0.57794106","0.5773347","0.57658297","0.5756176","0.5746563","0.5742477","0.57375574","0.57326686","0.5732589","0.57325757","0.5723362","0.5703566","0.56982154","0.569136","0.5689308","0.5687653","0.5678218","0.5647896","0.56313425","0.56277436","0.5624223","0.56238365","0.5614475","0.5606462","0.5606173","0.56033814","0.55993235","0.5594082","0.5572783","0.5559297","0.5546964","0.5546092","0.55439097","0.55283624","0.5523355","0.5523023","0.5519188","0.55177796","0.5514271","0.55012566","0.5493407","0.5492416","0.5490636","0.5487938","0.54837835","0.5482598","0.5471933","0.54715383","0.54641104","0.54589194","0.5456334","0.5455593","0.54474926"],"string":"[\n \"0.80750877\",\n \"0.7620803\",\n \"0.72162825\",\n \"0.69135714\",\n \"0.6852057\",\n \"0.6845415\",\n \"0.66279685\",\n \"0.6627276\",\n \"0.65779185\",\n \"0.6375827\",\n \"0.6368961\",\n \"0.6324704\",\n \"0.62609804\",\n \"0.62517524\",\n \"0.6210675\",\n \"0.6203783\",\n \"0.6160406\",\n \"0.61593336\",\n \"0.6152343\",\n \"0.6152343\",\n \"0.6096672\",\n \"0.6093078\",\n \"0.60796815\",\n \"0.6072978\",\n \"0.60647315\",\n \"0.6053542\",\n \"0.6046819\",\n \"0.6037067\",\n \"0.60321033\",\n \"0.60260093\",\n \"0.6006326\",\n \"0.5996785\",\n \"0.5988853\",\n \"0.59621197\",\n \"0.5949978\",\n \"0.59483516\",\n \"0.5947163\",\n \"0.59412795\",\n \"0.593777\",\n \"0.5913194\",\n \"0.59083414\",\n \"0.5886624\",\n \"0.5849588\",\n \"0.5817861\",\n \"0.5790656\",\n \"0.57889646\",\n \"0.5783504\",\n \"0.57794106\",\n \"0.5773347\",\n \"0.57658297\",\n \"0.5756176\",\n \"0.5746563\",\n \"0.5742477\",\n \"0.57375574\",\n \"0.57326686\",\n \"0.5732589\",\n \"0.57325757\",\n \"0.5723362\",\n \"0.5703566\",\n \"0.56982154\",\n \"0.569136\",\n \"0.5689308\",\n \"0.5687653\",\n \"0.5678218\",\n \"0.5647896\",\n \"0.56313425\",\n \"0.56277436\",\n \"0.5624223\",\n \"0.56238365\",\n \"0.5614475\",\n \"0.5606462\",\n \"0.5606173\",\n \"0.56033814\",\n \"0.55993235\",\n \"0.5594082\",\n \"0.5572783\",\n \"0.5559297\",\n \"0.5546964\",\n \"0.5546092\",\n \"0.55439097\",\n \"0.55283624\",\n \"0.5523355\",\n \"0.5523023\",\n \"0.5519188\",\n \"0.55177796\",\n \"0.5514271\",\n \"0.55012566\",\n \"0.5493407\",\n \"0.5492416\",\n \"0.5490636\",\n \"0.5487938\",\n \"0.54837835\",\n \"0.5482598\",\n \"0.5471933\",\n \"0.54715383\",\n \"0.54641104\",\n \"0.54589194\",\n \"0.5456334\",\n \"0.5455593\",\n \"0.54474926\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7185599"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9489,"cells":{"query":{"kind":"string","value":"Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def atlas_clusters():\n pass","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def gen_random_clusters(num_clusters):\n cluster_list = []\n\n for county_id in range(num_clusters):\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\n return cluster_list","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def atlas_clusters():\\n pass\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def gen_random_clusters(num_clusters):\\n cluster_list = []\\n\\n for county_id in range(num_clusters):\\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\\n return cluster_list\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7743275","0.7348963","0.7345636","0.72138846","0.693622","0.6857599","0.678586","0.6746427","0.6744042","0.6541813","0.6501836","0.65014625","0.6451203","0.631673","0.63058984","0.6281105","0.6236732","0.6231005","0.62132615","0.62098527","0.6208093","0.6208093","0.6198955","0.6150013","0.6138653","0.6138524","0.6136757","0.61291736","0.61262244","0.6115091","0.6112061","0.61116153","0.6109031","0.60979396","0.6094194","0.60915464","0.60855126","0.6063454","0.6049945","0.6006646","0.59817016","0.59614265","0.5960605","0.59592915","0.5948572","0.59466517","0.59299326","0.5925065","0.59240925","0.590385","0.5901532","0.5897844","0.58768183","0.58753186","0.58719885","0.5853302","0.58512014","0.58388853","0.58341026","0.58287597","0.58136463","0.5807794","0.5803428","0.5766285","0.57602394","0.57593936","0.5751862","0.5749475","0.57472575","0.57349306","0.5727445","0.57252026","0.5724762","0.5708919","0.5703779","0.5694693","0.5690951","0.568531","0.5680722","0.5680167","0.56788284","0.5675942","0.5674772","0.5670294","0.56648195","0.5647926","0.5645903","0.56450415","0.5643608","0.56413084","0.56320924","0.5628659","0.5624026","0.5605007","0.5601424","0.5599997","0.5589584","0.55865484","0.55811673","0.557521"],"string":"[\n \"0.7743275\",\n \"0.7348963\",\n \"0.7345636\",\n \"0.72138846\",\n \"0.693622\",\n \"0.6857599\",\n \"0.678586\",\n \"0.6746427\",\n \"0.6744042\",\n \"0.6541813\",\n \"0.6501836\",\n \"0.65014625\",\n \"0.6451203\",\n \"0.631673\",\n \"0.63058984\",\n \"0.6281105\",\n \"0.6236732\",\n \"0.6231005\",\n \"0.62132615\",\n \"0.62098527\",\n \"0.6208093\",\n \"0.6208093\",\n \"0.6198955\",\n \"0.6150013\",\n \"0.6138653\",\n \"0.6138524\",\n \"0.6136757\",\n \"0.61291736\",\n \"0.61262244\",\n \"0.6115091\",\n \"0.6112061\",\n \"0.61116153\",\n \"0.6109031\",\n \"0.60979396\",\n \"0.6094194\",\n \"0.60915464\",\n \"0.60855126\",\n \"0.6063454\",\n \"0.6049945\",\n \"0.6006646\",\n \"0.59817016\",\n \"0.59614265\",\n \"0.5960605\",\n \"0.59592915\",\n \"0.5948572\",\n \"0.59466517\",\n \"0.59299326\",\n \"0.5925065\",\n \"0.59240925\",\n \"0.590385\",\n \"0.5901532\",\n \"0.5897844\",\n \"0.58768183\",\n \"0.58753186\",\n \"0.58719885\",\n \"0.5853302\",\n \"0.58512014\",\n \"0.58388853\",\n \"0.58341026\",\n \"0.58287597\",\n \"0.58136463\",\n \"0.5807794\",\n \"0.5803428\",\n \"0.5766285\",\n \"0.57602394\",\n \"0.57593936\",\n \"0.5751862\",\n \"0.5749475\",\n \"0.57472575\",\n \"0.57349306\",\n \"0.5727445\",\n \"0.57252026\",\n \"0.5724762\",\n \"0.5708919\",\n \"0.5703779\",\n \"0.5694693\",\n \"0.5690951\",\n \"0.568531\",\n \"0.5680722\",\n \"0.5680167\",\n \"0.56788284\",\n \"0.5675942\",\n \"0.5674772\",\n \"0.5670294\",\n \"0.56648195\",\n \"0.5647926\",\n \"0.5645903\",\n \"0.56450415\",\n \"0.5643608\",\n \"0.56413084\",\n \"0.56320924\",\n \"0.5628659\",\n \"0.5624026\",\n \"0.5605007\",\n \"0.5601424\",\n \"0.5599997\",\n \"0.5589584\",\n \"0.55865484\",\n \"0.55811673\",\n \"0.557521\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.677395"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":9490,"cells":{"query":{"kind":"string","value":"Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def atlas_clusters():\n pass","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def gen_random_clusters(num_clusters):\n cluster_list = []\n\n for county_id in range(num_clusters):\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\n return cluster_list","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def atlas_clusters():\\n pass\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def gen_random_clusters(num_clusters):\\n cluster_list = []\\n\\n for county_id in range(num_clusters):\\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\\n return cluster_list\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7741456","0.7347127","0.7343865","0.69358754","0.68556786","0.6784003","0.67725694","0.67446214","0.6744467","0.6542266","0.65019643","0.6500571","0.6449538","0.6316034","0.63062775","0.6281654","0.62352514","0.62311894","0.6211723","0.6209921","0.62071943","0.62071943","0.61985546","0.61488694","0.6138476","0.61365694","0.6136153","0.61297363","0.6125074","0.6114406","0.6112055","0.61100966","0.61086065","0.60975","0.60933566","0.609119","0.6083763","0.6063869","0.60482055","0.60071856","0.59797853","0.59607786","0.59590757","0.595767","0.5948209","0.5946687","0.5927359","0.5925263","0.59226024","0.59040797","0.5900065","0.58977884","0.5874954","0.58738995","0.58721626","0.58515394","0.5851261","0.5838344","0.5833107","0.58270884","0.5814174","0.58065903","0.58049965","0.5765693","0.5758973","0.57586133","0.5749749","0.5748424","0.5745475","0.5734116","0.5727107","0.57232934","0.57224935","0.5709228","0.5703725","0.569185","0.56886286","0.5685073","0.56818295","0.5678877","0.56772214","0.56754935","0.5674598","0.5669433","0.56642944","0.56475866","0.5645131","0.56448114","0.5642601","0.5641719","0.56316024","0.56280565","0.56213427","0.5605073","0.5601148","0.56004703","0.5587106","0.5587088","0.5579642","0.5575142"],"string":"[\n \"0.7741456\",\n \"0.7347127\",\n \"0.7343865\",\n \"0.69358754\",\n \"0.68556786\",\n \"0.6784003\",\n \"0.67725694\",\n \"0.67446214\",\n \"0.6744467\",\n \"0.6542266\",\n \"0.65019643\",\n \"0.6500571\",\n \"0.6449538\",\n \"0.6316034\",\n \"0.63062775\",\n \"0.6281654\",\n \"0.62352514\",\n \"0.62311894\",\n \"0.6211723\",\n \"0.6209921\",\n \"0.62071943\",\n \"0.62071943\",\n \"0.61985546\",\n \"0.61488694\",\n \"0.6138476\",\n \"0.61365694\",\n \"0.6136153\",\n \"0.61297363\",\n \"0.6125074\",\n \"0.6114406\",\n \"0.6112055\",\n \"0.61100966\",\n \"0.61086065\",\n \"0.60975\",\n \"0.60933566\",\n \"0.609119\",\n \"0.6083763\",\n \"0.6063869\",\n \"0.60482055\",\n \"0.60071856\",\n \"0.59797853\",\n \"0.59607786\",\n \"0.59590757\",\n \"0.595767\",\n \"0.5948209\",\n \"0.5946687\",\n \"0.5927359\",\n \"0.5925263\",\n \"0.59226024\",\n \"0.59040797\",\n \"0.5900065\",\n \"0.58977884\",\n \"0.5874954\",\n \"0.58738995\",\n \"0.58721626\",\n \"0.58515394\",\n \"0.5851261\",\n \"0.5838344\",\n \"0.5833107\",\n \"0.58270884\",\n \"0.5814174\",\n \"0.58065903\",\n \"0.58049965\",\n \"0.5765693\",\n \"0.5758973\",\n \"0.57586133\",\n \"0.5749749\",\n \"0.5748424\",\n \"0.5745475\",\n \"0.5734116\",\n \"0.5727107\",\n \"0.57232934\",\n \"0.57224935\",\n \"0.5709228\",\n \"0.5703725\",\n \"0.569185\",\n \"0.56886286\",\n \"0.5685073\",\n \"0.56818295\",\n \"0.5678877\",\n \"0.56772214\",\n \"0.56754935\",\n \"0.5674598\",\n \"0.5669433\",\n \"0.56642944\",\n \"0.56475866\",\n \"0.5645131\",\n \"0.56448114\",\n \"0.5642601\",\n \"0.5641719\",\n \"0.56316024\",\n \"0.56280565\",\n \"0.56213427\",\n \"0.5605073\",\n \"0.5601148\",\n \"0.56004703\",\n \"0.5587106\",\n \"0.5587088\",\n \"0.5579642\",\n \"0.5575142\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72126484"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":9491,"cells":{"query":{"kind":"string","value":"Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def atlas_clusters():\n pass","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def gen_random_clusters(num_clusters):\n cluster_list = []\n\n for county_id in range(num_clusters):\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\n return cluster_list","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def atlas_clusters():\\n pass\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def gen_random_clusters(num_clusters):\\n cluster_list = []\\n\\n for county_id in range(num_clusters):\\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\\n return cluster_list\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7742221","0.734794","0.7344126","0.7212588","0.6936357","0.678427","0.67730224","0.6745758","0.67450356","0.65422076","0.65023965","0.6501117","0.6449754","0.63159335","0.6306894","0.628159","0.6236001","0.6232418","0.6210907","0.62107736","0.62073714","0.62073714","0.61983794","0.6149534","0.6138597","0.6137169","0.61369187","0.61293036","0.6124557","0.611428","0.61126417","0.6110925","0.6108145","0.60976994","0.6093042","0.6090669","0.6084699","0.60638726","0.6049553","0.6007336","0.5981543","0.5960686","0.59591025","0.5957989","0.5948937","0.59477144","0.59281296","0.59253377","0.5922185","0.59035057","0.59000164","0.5897559","0.5876768","0.5873851","0.587221","0.58514166","0.5851201","0.584017","0.5831893","0.58269316","0.58144003","0.5807502","0.5805853","0.5765498","0.575936","0.5757784","0.57489413","0.5748162","0.57463056","0.57343584","0.5725802","0.572358","0.572346","0.57085","0.5704501","0.569267","0.5689642","0.5683907","0.56819654","0.56787944","0.56782466","0.5675327","0.56752896","0.5670172","0.5663546","0.56469405","0.5645751","0.56450665","0.5643172","0.5641172","0.56317216","0.56273246","0.5621972","0.5605826","0.56005573","0.5599716","0.55875266","0.5587495","0.5579519","0.5576352"],"string":"[\n \"0.7742221\",\n \"0.734794\",\n \"0.7344126\",\n \"0.7212588\",\n \"0.6936357\",\n \"0.678427\",\n \"0.67730224\",\n \"0.6745758\",\n \"0.67450356\",\n \"0.65422076\",\n \"0.65023965\",\n \"0.6501117\",\n \"0.6449754\",\n \"0.63159335\",\n \"0.6306894\",\n \"0.628159\",\n \"0.6236001\",\n \"0.6232418\",\n \"0.6210907\",\n \"0.62107736\",\n \"0.62073714\",\n \"0.62073714\",\n \"0.61983794\",\n \"0.6149534\",\n \"0.6138597\",\n \"0.6137169\",\n \"0.61369187\",\n \"0.61293036\",\n \"0.6124557\",\n \"0.611428\",\n \"0.61126417\",\n \"0.6110925\",\n \"0.6108145\",\n \"0.60976994\",\n \"0.6093042\",\n \"0.6090669\",\n \"0.6084699\",\n \"0.60638726\",\n \"0.6049553\",\n \"0.6007336\",\n \"0.5981543\",\n \"0.5960686\",\n \"0.59591025\",\n \"0.5957989\",\n \"0.5948937\",\n \"0.59477144\",\n \"0.59281296\",\n \"0.59253377\",\n \"0.5922185\",\n \"0.59035057\",\n \"0.59000164\",\n \"0.5897559\",\n \"0.5876768\",\n \"0.5873851\",\n \"0.587221\",\n \"0.58514166\",\n \"0.5851201\",\n \"0.584017\",\n \"0.5831893\",\n \"0.58269316\",\n \"0.58144003\",\n \"0.5807502\",\n \"0.5805853\",\n \"0.5765498\",\n \"0.575936\",\n \"0.5757784\",\n \"0.57489413\",\n \"0.5748162\",\n \"0.57463056\",\n \"0.57343584\",\n \"0.5725802\",\n \"0.572358\",\n \"0.572346\",\n \"0.57085\",\n \"0.5704501\",\n \"0.569267\",\n \"0.5689642\",\n \"0.5683907\",\n \"0.56819654\",\n \"0.56787944\",\n \"0.56782466\",\n \"0.5675327\",\n \"0.56752896\",\n \"0.5670172\",\n \"0.5663546\",\n \"0.56469405\",\n \"0.5645751\",\n \"0.56450665\",\n \"0.5643172\",\n \"0.5641172\",\n \"0.56317216\",\n \"0.56273246\",\n \"0.5621972\",\n \"0.5605826\",\n \"0.56005573\",\n \"0.5599716\",\n \"0.55875266\",\n \"0.5587495\",\n \"0.5579519\",\n \"0.5576352\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6856434"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":9492,"cells":{"query":{"kind":"string","value":"Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance"},"document":{"kind":"string","value":"def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]"},"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 _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def _10x10_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def _2x3_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def _5x5_grid_clusters_close():\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=n)]","def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n\n strength = np.linspace(0, 0.8, len(self.unique_labels))\n np.random.shuffle(strength)\n colors = [plt.cm.nipy_spectral(each) for each in strength]\n np.random.shuffle(strength)\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\n\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\n a = 1\n s = 3\n if k == -1:\n # Black used for noise.\n col = [1, 0, 0]\n a = 0.3\n s = 1\n\n class_member_mask = (self.labels == k)\n xy = self.data[class_member_mask]\n if len(xy) > 0:\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def clusters_allocate_cells(self):\n for cluster in self.clusters:\n cluster.cells[:] = []\n for cell in self.block_proc:\n wdists = []\n for cluster in self.clusters:\n s = cluster.size\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\n (cell.z-cluster.z)**2 )\n d = numpy.sqrt(d)\n c = self.c\n # TODO: choose a better distance function below\n r = d*(c+(1-c)*numpy.exp(-s/d))\n r = numpy.clip(r,0,r)\n wdists.append(r)\n self.clusters[numpy.argmin(wdists)].cells.append(cell)","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def __get_centers(data, clusters):\n\n centers = [[] for i in range(len(clusters))]\n dimension = len(data[0])\n\n for index in range(len(clusters)):\n point_sum = [0.0] * dimension\n\n for index_point in clusters[index]:\n point_sum = list_math_addition(point_sum, data[index_point])\n\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\n\n return centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def c_centers_with_ghost(self,num_ghost):\n self.compute_c_centers_with_ghost(num_ghost)\n return self._c_centers_with_ghost","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\n maxIndex = matrix.shape[0]-1\n quarterRange = midRange/2\n\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\n noiseLevel = roughness * pf\n\n \"\"\"\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\n to determine the points that should be averaged and the point to be set. \n setValue does the calculations.\n \"\"\"\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\n setValue(matrix, center, indexRef, noiseLevel)\n \n\n #printAllowCancel(matrix)","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def atlas_clusters():\n pass","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\n \n #Number of samples in each cluster\n N1 = int(np.floor(1.0*N/2))\n N2 = N - N1\n \n phi1 = np.random.rand(N1,1) * 2 * np.pi;\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\n d1x = dist1* np.cos(phi1) \n d1y = dist1* np.sin(phi1) \n cluster1 = np.concatenate((d1x,d1y,\\\n np.zeros((N1,1))),axis = 1)\n \n perarm = int(np.round(N2/arms))\n N2 = perarm*arms;\n radperarm = (2*np.pi)/arms;\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm*(radperarm)\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\n dtype=int)%perarm)/perarm\n d2x = dist2*np.cos(phi2)\n d2y = dist2*np.sin(phi2)\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\n np.ones((N2,1))),axis = 1) \n \n #Concatenating the final data\n data = np.concatenate((cluster1,cluster2),axis = 0)\n return data","def get_square_centers(self):\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\n x_values *= self.spacing\n x_values += self.center[0] # add x-coordinate for grid center\n y_values *= self.spacing\n y_values += self.center[1] # add y-coordinate for grid center\n return np.dstack((x_values, y_values))","def plt_gm_clusters(df_all, model):\n\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\n\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\n\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\n\n XX = df.values\n Y_ = model.predict(XX) # predict labels for each model\n\n plt.figure(figsize=(8, 6))\n splot = plt.subplot(1, 1, 1)\n\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\n\n if \"MEAN\" in clus_params['feat_list']:\n v, w = linalg.eigh(cov)\n else:\n\n subset = [0, 5] # mean torque L & R\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\n mean = np.array([mean[0], mean[5]])\n\n if not np.any(Y_ == i):\n continue\n\n if \"MEAN\" in clus_params['feat_list']:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\n else:\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\n\n # Plot an ellipse to show the Gaussian component\n angle = np.arctan2(w[0][1], w[0][0])\n angle = 180. * angle / np.pi # convert to degrees\n v = 2. * np.sqrt(2.) * np.sqrt(v)\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\n ell.set_clip_box(splot.bbox)\n ell.set_alpha(.5)\n splot.add_artist(ell)\n\n plt.xticks(())\n plt.yticks(())\n\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\n plt.subplots_adjust(hspace=.35, bottom=.02)\n plt.show()","def adaptiveCentroid(data=None,sigma=None):\n nrow,ncol=data.shape\n Isum = data.sum()\n Icol = data.sum(axis=0) # sum over all rows\n Irow = data.sum(axis=1) # sum over all cols\n colgrid = np.arange(ncol)\n rowgrid = np.arange(nrow)\n rowmean=np.sum(rowgrid*Irow)/Isum\n colmean=np.sum(colgrid*Icol)/Isum\n ROW,COL=np.indices((nrow,ncol))\n maxItr = 50\n EP = 0.0001\n for i in range(maxItr):\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\n IWmat = data*wrmat\n IWcol = IWmat.sum(axis=0)\n IWrow = IWmat.sum(axis=1)\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\n rowmean = rowmean+2.*drowmean\n colmean = colmean+2.*dcolmean\n if drowmean**2+dcolmean**2 <= EP:\n break\n\n return rowmean,colmean","def fit(self, data): \n \"\"\"\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\n \n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\n where the third channel is used to indicate the cluster of each point in the data set.\n \"\"\"\n old_clusters = self.random_assignment_of_clusters(data)\n while True:\n centroids = self.calculate_centroids(data, old_clusters)\n new_clusters = self.assign_clusters(data, centroids)\n if (new_clusters==old_clusters).all():\n break\n old_clusters=new_clusters \n return new_clusters, centroids","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def cluster(ops, seeds, mut):\n\n old_centers = []\n centers = copy.deepcopy(seeds)\n\n while (set(centers) != set(old_centers)):\n\n old_centers = copy.deepcopy(centers)\n centers = []\n groups = grouping(old_centers, ops, mut)\n\n for i in range(len(groups)):\n result = group_evaluation(groups[i], mut)\n centers.append(result)\n\n return centers","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\r\n #create a cluster of shapes on an elevation map\r\n blist = []\r\n for v in range(count):\r\n x = xpos + random.random() * w - w * 0.5\r\n z = zpos + random.random() * d - d * 0.5\r\n rh = random.random() * (maxscl - minscl) + minscl\r\n rt = random.random() * 360.0\r\n y = elevmap.calcHeight(x, z) + rh * 2\r\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\r\n\r\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\r\n self.merge(blist)","def plot_center(centers):\n N,D = centers.shape\n k = 0\n for i in range(0, D-1):\n for j in range(i+1, D):\n plt.figure(k)\n k = k+1\n plt.scatter(centers[:, i], centers[:, j])\n plt.show()","def _initial_clusters(self):\n clusters = []\n for i in range(self.point_count):\n clusters.append(self._create_cluster_from_index(i))\n return clusters","def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\n cell_np = {}\n for tmp_cells_np in self.proc_block_np:\n cell_np.update(tmp_cells_np)\n self.cell_np = cell_np\n if proc_cells is None:\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\n self.cell_np, self.num_procs)\n self.np_req = numpy.average(proc_num_particles)\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \n for cells in proc_cells]\n self.calc()","def compute_centers_of_hypercubes(self):\n for hc in self.hypercubes.flatten():\n for i in range(self.dims - 1, -1, -1):\n index = self.dims - (i + 1)\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]","def gen_center_points(x_res, y_res, dim):\n center_points = []\n\n for x in range(math.floor(dim[0] / x_res)):\n for y in range(math.floor(dim[1] / y_res)):\n x = (x + 1) * x_res\n y = (y + 1) * y_res\n center_points.append((x, y))\n\n return center_points","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def initial_clusters(self, points):\n groups = {}\n d = int(256 / (self.initial_k))\n for i in range(self.initial_k):\n j = i * d\n groups[(j, j, j)] = []\n for i, p in enumerate(points):\n # if i%100000 == 0:\n # print('processing pixel:', i)\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \n groups[go].append(p)\n return [g for g in groups.values() if len(g) > 0]","def cluster_plot(self):\r\n train = StandardScaler().fit_transform(self.X)\r\n pca = PCA(n_components=3)\r\n pca_component = pca.fit_transform(self.X)\r\n fig = plt.figure(figsize=(10,8))\r\n sns.set_palette(sns.color_palette(\"cubehelix\", 8))\r\n ax = Axes3D(fig)\r\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\r\n ax.legend()\r\n plt.show()","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def k_clusters(old_ops, max_outputs, mut):\n \n # DM construction\n matrix = starting_centroids(old_ops, max_outputs, mut)\n\n\n # Clustering\n seed = []\n for i in matrix.OPs:\n seed.append(i)\n centroids = cluster(old_ops, seed, mut)\n disto = distortion(centroids, old_ops, mut)\n\n return centroids, disto","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def kmeans(bboxes, k, dist=np.median):\n rows = bboxes.shape[0]\n\n distances = np.empty((rows, k))\n last_clusters = np.zeros((rows,))\n\n np.random.seed()\n\n # the Forgy method will fail if the whole array contains the same rows\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\n\n while True:\n for row in range(rows):\n distances[row] = 1 - iou(bboxes[row], clusters)\n\n nearest_clusters = np.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n for cluster in range(k):\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\n\n last_clusters = nearest_clusters\n\n return clusters","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\n print(\"Starting RGBXY K-Means algorithm...\")\n # convert BGR to RGB\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n h, w, d = np.shape(im)\n im_vector = im.reshape((-1, 3))\n arr = [[[j, i] for i in range(w)] for j in range(h)]\n arr = np.asarray(arr)\n im_vector_xy = arr.reshape((-1, 2))\n # cluster_centers ~ initialization\n\n # pick random x and y and choose their rgb value\n np.random.seed(100)\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\n cluster_centers_xy = np.asarray(cluster_centers_xy)\n cluster_centers_xy.reshape((k, -1))\n cluster_centers_xy = cluster_centers_xy.transpose()\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\n cluster_centers_rgb = []\n for cluster in cluster_centers_xy:\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\n\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\n # dist = dist.reshape(len(dist),-1)\n\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\n distance_moved = float('inf')\n # convergence threshold\n thresh = 20\n if (k >= 10):\n thresh = 20\n if (k >= 25):\n thresh = 45 # 50\n if (k >= 50):\n thresh = 85 # 90\n if (k >= 100):\n thresh = 300\n if (k >= 250):\n thresh = 430\n final_cluster_points = 0\n\n while (distance_moved > thresh):\n\n # initialize empty cluster bins\n cluster_points = []\n for i in range(k):\n cluster_points.append([])\n\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\n\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\n\n # allocate cluster center to each pixel\n it = 0\n for i in range(0, len(dist), k):\n current_dist = dist[i: i + k]\n min_value = min(current_dist)\n min_position = np.argmin(current_dist)\n # segregate the points in k bins\n # append point index\n cluster_points[min_position].append(it)\n it += 1\n\n # recompute cluster centers\n distance_moved = 0\n for i in range(k):\n cp = cluster_points[i]\n # get points\n a = im_vector[cp]\n b = im_vector_xy[cp]\n if (len(a)):\n new_centers = a.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\n # update new cluster centers\n cluster_centers_rgb[i] = new_centers\n if (len(b)):\n new_centers = b.mean(axis=0)\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\n # update new cluster centers\n cluster_centers_xy[i] = new_centers\n\n # for cp in cluster_points:\n # print(np.shape(cp))\n\n final_cluster_points = cluster_points\n\n print(distance_moved)\n\n index_vector = np.empty([len(im_vector), 1])\n # cp is the point instances\n for i in range(k):\n cp = final_cluster_points[i]\n # print(np.shape(cp))\n index_vector[cp] = i\n segmap = index_vector.reshape((h, w))\n # print(segmap)\n # print(np.shape(segmap))\n # at every location, put the corresponding cluster number\n # segmap = np.empty()\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\n return segmap","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def kmeans(self,initial_centers=None,tolerance=0):\r\n\t\tcenters = initial_centers \\\r\n\t\t\t\tif initial_centers is not None else self.centers()\r\n\t\t\r\n\t\titerations = 0\r\n\t\twhile True:\r\n\t\t\titerations = iterations + 1\r\n\t\t\tclusters = dict([(i,[]) for i in xrange(self.k)])\r\n\t\t\tfor a in self.data:\r\n\t\t\t\tcc = self.closest_center(centers, a)\r\n\t\t\t\tcenter = cc[0]\r\n\t\t\t\tlabel = center[0]\r\n\t\t\t\tclusters[label].append(a)\r\n\r\n\t\t\tfor label, data_points in clusters.iteritems():\r\n\t\t\t\tif not data_points:\r\n\t\t\t\t\tcenters = self.centers()\r\n\t\t\t\t\tbreak # restart at random\r\n\r\n\t\t\t\tcenter = centers[label]\r\n\t\t\t\told_center_x, old_center_y = center[1], center[2]\r\n\t\t\t\tnew_center_x, new_center_y = self.mean(data_points)\r\n\r\n\t\t\t\tif abs(new_center_x - old_center_x) <= tolerance \\\r\n\t\t\t\t\t\tand abs(new_center_y - old_center_y) <= tolerance:\r\n\t\t\t\t\t# converged\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t'iterations' : iterations,\r\n\t\t\t\t\t\t\t'clusters' : clusters, \\\r\n\t\t\t\t\t\t\t'centers' : centers }\r\n\r\n\t\t\t\t# update center to mean\r\n\t\t\t\tcenter[1] = new_center_x\r\n\t\t\t\tcenter[2] = new_center_y","def _init_homolog_centers(self, method=\"kmeans\", min_spot_num=2, axis_infos=Axis3D_infos):\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\n if self.verbose:\n print(f\"- directly return chr_2_homolog_centers\")\n return\n if method == 'kmeans':\n from sklearn.cluster import KMeans\n # chr_2_init_centers\n self.chr_2_homolog_centers = {}\n self.chr_2_cand_hzxys = {}\n self.chr_2_cand_ids = {}\n # loop through chrs\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\n # if not spots exists, skip\n if len(_chr_coords_df) < min_spot_num:\n continue\n # get coordinates\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\"center_{_x}\" for _x in axis_infos]].values\n _chr_ids = _chr_coords_df['chr_order'].values\n # append\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\n self.chr_2_cand_ids[_chr_name] = _chr_ids\n # calculate weights\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\n # K-means\n if method =='kmeans':\n _model = KMeans(n_clusters=_exp_num, random_state=0)\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\n #_init_labels = _model.labels_\n _init_centers = _model.cluster_centers_\n # save for now\n self.chr_2_homolog_centers[_chr_name] = _init_centers","def gen_random_clusters(num_clusters):\n cluster_list = []\n\n for county_id in range(num_clusters):\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\n return cluster_list","def __initialise_smart(self, X, args):\n\t\tcentroids = np.zeros((self.K,self.D))\n\t\tif X.shape[0] > 10*self.K:\n\t\t\tdata = X[:10*self.K,:]\n\t\telse:\n\t\t\tdata = X\n\t\tN = data.shape[0]\n\n\t\t\t#choosing centroids\n\t\t\t#points are chosen from dataset with farhtest point clustering\n\t\tran_index = np.random.choice(N)\n\t\tcentroids[0,:] = data[ran_index]\n\n\t\tfor k in range(1,self.K):\n\t\t\tdistances = np.zeros((N,k)) #(N,K)\n\t\t\tfor k_prime in range(k):\n\t\t\t\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\n\t\t\tdistances = np.min(distances, axis = 1) #(N,)\n\t\t\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\n\t\t\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\n\t\t\tcentroids[k,:] = data[next_cl_arg,:]\n\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def c_centers(self):\n self.compute_c_centers(self)\n return self._c_centers","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def test_one_center(self):\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\n atom2rcut=np.array([5.0])\n g = dft.gen_grid.Grids(sv)\n g.level = 1 # precision as implemented in pyscf\n g.radi_method=leggauss_ab\n g.build(atom2rcut=atom2rcut)\n\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\n self.assertEqual(len(g.weights), 6248)"],"string":"[\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def _10x10_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def _2x3_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def _5x5_grid_clusters_close():\\n return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def _random_standard_centers(n=100):\\n generator = mn(mean=np.array([0, 0]),\\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\\n for pt in generator.rvs(size=n)]\",\n \"def plotClusters(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n\\n strength = np.linspace(0, 0.8, len(self.unique_labels))\\n np.random.shuffle(strength)\\n colors = [plt.cm.nipy_spectral(each) for each in strength]\\n np.random.shuffle(strength)\\n colorsB = [plt.cm.nipy_spectral(each) for each in strength]\\n\\n for k, col, colB in zip(self.unique_labels, colors, colorsB):\\n a = 1\\n s = 3\\n if k == -1:\\n # Black used for noise.\\n col = [1, 0, 0]\\n a = 0.3\\n s = 1\\n\\n class_member_mask = (self.labels == k)\\n xy = self.data[class_member_mask]\\n if len(xy) > 0:\\n ax.scatter(xy[:, 0], xy[:, 1], xy[:, 2], c=np.reshape(np.array(col), (1, -1)),\\n edgecolors=np.reshape(np.array(colB), (1, -1)), alpha=a, s=s, label='Cluster ' + str(k))\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def clusters_allocate_cells(self):\\n for cluster in self.clusters:\\n cluster.cells[:] = []\\n for cell in self.block_proc:\\n wdists = []\\n for cluster in self.clusters:\\n s = cluster.size\\n d = ( (cell.x-cluster.x)**2 + (cell.y-cluster.y)**2 +\\n (cell.z-cluster.z)**2 )\\n d = numpy.sqrt(d)\\n c = self.c\\n # TODO: choose a better distance function below\\n r = d*(c+(1-c)*numpy.exp(-s/d))\\n r = numpy.clip(r,0,r)\\n wdists.append(r)\\n self.clusters[numpy.argmin(wdists)].cells.append(cell)\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def __get_centers(data, clusters):\\n\\n centers = [[] for i in range(len(clusters))]\\n dimension = len(data[0])\\n\\n for index in range(len(clusters)):\\n point_sum = [0.0] * dimension\\n\\n for index_point in clusters[index]:\\n point_sum = list_math_addition(point_sum, data[index_point])\\n\\n centers[index] = list_math_division_number(point_sum, len(clusters[index]))\\n\\n return centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def c_centers_with_ghost(self,num_ghost):\\n self.compute_c_centers_with_ghost(num_ghost)\\n return self._c_centers_with_ghost\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def populateCenters(matrix, row, col, frame, midRange, roughness, perturbance):\\n maxIndex = matrix.shape[0]-1\\n quarterRange = midRange/2\\n\\n pf = perturbanceFactor(matrix.shape[0], midRange, perturbance)\\n noiseLevel = roughness * pf\\n\\n \\\"\\\"\\\"\\n For each subdivided cube, getIndexRef is used to get the indicies, and center is used\\n to determine the points that should be averaged and the point to be set. \\n setValue does the calculations.\\n \\\"\\\"\\\"\\n indexRef = getIndexRef(row, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n indexRef = getIndexRef(row + midRange, col + midRange, frame + midRange, quarterRange, maxIndex)\\n setValue(matrix, center, indexRef, noiseLevel)\\n \\n\\n #printAllowCancel(matrix)\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def atlas_clusters():\\n pass\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def concentric_clusters(N = 1000, r1 = 1, r2 = 5, w1 = 0.8, w2 = 1.0/3, arms = 64):\\n \\n #Number of samples in each cluster\\n N1 = int(np.floor(1.0*N/2))\\n N2 = N - N1\\n \\n phi1 = np.random.rand(N1,1) * 2 * np.pi;\\n dist1 = r1 + 1.0*(np.random.randint(0,5,size =(N1,1)))/5*w1*r1\\n d1x = dist1* np.cos(phi1) \\n d1y = dist1* np.sin(phi1) \\n cluster1 = np.concatenate((d1x,d1y,\\\\\\n np.zeros((N1,1))),axis = 1)\\n \\n perarm = int(np.round(N2/arms))\\n N2 = perarm*arms;\\n radperarm = (2*np.pi)/arms;\\n phi2 = 1.0*(np.arange(1,N2+1,dtype = int) - np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm*(radperarm)\\n dist2 = r2 * (1 - w2/2) + (r2*w2*np.arange(1,N2+1,\\\\\\n dtype=int)%perarm)/perarm\\n d2x = dist2*np.cos(phi2)\\n d2y = dist2*np.sin(phi2)\\n cluster2 = np.concatenate((d2x[:,np.newaxis],d2y[:,np.newaxis],\\\\\\n np.ones((N2,1))),axis = 1) \\n \\n #Concatenating the final data\\n data = np.concatenate((cluster1,cluster2),axis = 0)\\n return data\",\n \"def get_square_centers(self):\\n x_values = np.arange(-2, 4, 2) * np.ones(self.GRID_SHAPE)\\n y_values = np.arange(2, -4, -2).reshape((3, 1)) * np.ones(self.GRID_SHAPE)\\n x_values *= self.spacing\\n x_values += self.center[0] # add x-coordinate for grid center\\n y_values *= self.spacing\\n y_values += self.center[1] # add y-coordinate for grid center\\n return np.dstack((x_values, y_values))\",\n \"def plt_gm_clusters(df_all, model):\\n\\n # color_iter = itertools.cycle([cmap(i) for i in range(cmap.N)])\\n\\n color_iter = itertools.cycle([cmap(i) for i in range(clus_params['n_components'])])\\n\\n df = df_all[featureSet_dic[clus_params['feat_list']]].copy()\\n\\n XX = df.values\\n Y_ = model.predict(XX) # predict labels for each model\\n\\n plt.figure(figsize=(8, 6))\\n splot = plt.subplot(1, 1, 1)\\n\\n for i, (mean, cov, color) in enumerate(zip(model.means_, model.covariances_, color_iter)):\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n v, w = linalg.eigh(cov)\\n else:\\n\\n subset = [0, 5] # mean torque L & R\\n v, w = linalg.eigh(cov[np.ix_(subset, subset)])\\n mean = np.array([mean[0], mean[5]])\\n\\n if not np.any(Y_ == i):\\n continue\\n\\n if \\\"MEAN\\\" in clus_params['feat_list']:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 1], color=color, s=60)\\n else:\\n plt.scatter(XX[Y_ == i, 0], XX[Y_ == i, 5], color=color, s=60)\\n\\n # Plot an ellipse to show the Gaussian component\\n angle = np.arctan2(w[0][1], w[0][0])\\n angle = 180. * angle / np.pi # convert to degrees\\n v = 2. * np.sqrt(2.) * np.sqrt(v)\\n ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)\\n ell.set_clip_box(splot.bbox)\\n ell.set_alpha(.5)\\n splot.add_artist(ell)\\n\\n plt.xticks(())\\n plt.yticks(())\\n\\n plt.title('Subject: {}, feature set: {}'.format(USER, clus_params['feat_list']))\\n plt.subplots_adjust(hspace=.35, bottom=.02)\\n plt.show()\",\n \"def adaptiveCentroid(data=None,sigma=None):\\n nrow,ncol=data.shape\\n Isum = data.sum()\\n Icol = data.sum(axis=0) # sum over all rows\\n Irow = data.sum(axis=1) # sum over all cols\\n colgrid = np.arange(ncol)\\n rowgrid = np.arange(nrow)\\n rowmean=np.sum(rowgrid*Irow)/Isum\\n colmean=np.sum(colgrid*Icol)/Isum\\n ROW,COL=np.indices((nrow,ncol))\\n maxItr = 50\\n EP = 0.0001\\n for i in range(maxItr):\\n wrmat = wr(ROW,COL,rowmean,colmean,sigma)\\n IWmat = data*wrmat\\n IWcol = IWmat.sum(axis=0)\\n IWrow = IWmat.sum(axis=1)\\n drowmean = np.sum((rowgrid-rowmean)*IWrow)/np.sum(IWrow)\\n dcolmean = np.sum((colgrid-colmean)*IWcol)/np.sum(IWcol)\\n rowmean = rowmean+2.*drowmean\\n colmean = colmean+2.*dcolmean\\n if drowmean**2+dcolmean**2 <= EP:\\n break\\n\\n return rowmean,colmean\",\n \"def fit(self, data): \\n \\\"\\\"\\\"\\n Takes a 2D numpy array of shape=(n, 2), where n is the number of samples in the dataset.\\n \\n Returns a numpy array that has shape=(n,) that contains the cluster of each data sample,\\n where the third channel is used to indicate the cluster of each point in the data set.\\n \\\"\\\"\\\"\\n old_clusters = self.random_assignment_of_clusters(data)\\n while True:\\n centroids = self.calculate_centroids(data, old_clusters)\\n new_clusters = self.assign_clusters(data, centroids)\\n if (new_clusters==old_clusters).all():\\n break\\n old_clusters=new_clusters \\n return new_clusters, centroids\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def cluster(ops, seeds, mut):\\n\\n old_centers = []\\n centers = copy.deepcopy(seeds)\\n\\n while (set(centers) != set(old_centers)):\\n\\n old_centers = copy.deepcopy(centers)\\n centers = []\\n groups = grouping(old_centers, ops, mut)\\n\\n for i in range(len(groups)):\\n result = group_evaluation(groups[i], mut)\\n centers.append(result)\\n\\n return centers\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def cluster(self, bufr, elevmap, xpos, zpos, w, d, count, options, minscl, maxscl):\\r\\n #create a cluster of shapes on an elevation map\\r\\n blist = []\\r\\n for v in range(count):\\r\\n x = xpos + random.random() * w - w * 0.5\\r\\n z = zpos + random.random() * d - d * 0.5\\r\\n rh = random.random() * (maxscl - minscl) + minscl\\r\\n rt = random.random() * 360.0\\r\\n y = elevmap.calcHeight(x, z) + rh * 2\\r\\n blist.append([bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh])\\r\\n\\r\\n #self.merge(bufr, x, y, z, 0.0, rt, 0.0, rh, rh, rh)\\r\\n self.merge(blist)\",\n \"def plot_center(centers):\\n N,D = centers.shape\\n k = 0\\n for i in range(0, D-1):\\n for j in range(i+1, D):\\n plt.figure(k)\\n k = k+1\\n plt.scatter(centers[:, i], centers[:, j])\\n plt.show()\",\n \"def _initial_clusters(self):\\n clusters = []\\n for i in range(self.point_count):\\n clusters.append(self._create_cluster_from_index(i))\\n return clusters\",\n \"def gen_clusters(self, proc_cells=None, proc_num_particles=None, **kwargs):\\n cell_np = {}\\n for tmp_cells_np in self.proc_block_np:\\n cell_np.update(tmp_cells_np)\\n self.cell_np = cell_np\\n if proc_cells is None:\\n proc_cells, proc_num_particles = LoadBalancer.distribute_particles_geometric(\\n self.cell_np, self.num_procs)\\n self.np_req = numpy.average(proc_num_particles)\\n self.clusters = [Cluster(cells, cell_np, self.np_req, **kwargs) \\n for cells in proc_cells]\\n self.calc()\",\n \"def compute_centers_of_hypercubes(self):\\n for hc in self.hypercubes.flatten():\\n for i in range(self.dims - 1, -1, -1):\\n index = self.dims - (i + 1)\\n hc.center[i] = (hc.coords[index] + 0.5) * self.hypercube_measurements[index]\",\n \"def gen_center_points(x_res, y_res, dim):\\n center_points = []\\n\\n for x in range(math.floor(dim[0] / x_res)):\\n for y in range(math.floor(dim[1] / y_res)):\\n x = (x + 1) * x_res\\n y = (y + 1) * y_res\\n center_points.append((x, y))\\n\\n return center_points\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def initial_clusters(self, points):\\n groups = {}\\n d = int(256 / (self.initial_k))\\n for i in range(self.initial_k):\\n j = i * d\\n groups[(j, j, j)] = []\\n for i, p in enumerate(points):\\n # if i%100000 == 0:\\n # print('processing pixel:', i)\\n go = min(groups.keys(), key=lambda c: euclidean_distance(p, c)) \\n groups[go].append(p)\\n return [g for g in groups.values() if len(g) > 0]\",\n \"def cluster_plot(self):\\r\\n train = StandardScaler().fit_transform(self.X)\\r\\n pca = PCA(n_components=3)\\r\\n pca_component = pca.fit_transform(self.X)\\r\\n fig = plt.figure(figsize=(10,8))\\r\\n sns.set_palette(sns.color_palette(\\\"cubehelix\\\", 8))\\r\\n ax = Axes3D(fig)\\r\\n ax.scatter(pca_component[:,0].tolist(),pca_component[:,1].tolist(),pca_component[:,2].tolist(),c=self.labels,marker='v')\\r\\n ax.legend()\\r\\n plt.show()\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def k_clusters(old_ops, max_outputs, mut):\\n \\n # DM construction\\n matrix = starting_centroids(old_ops, max_outputs, mut)\\n\\n\\n # Clustering\\n seed = []\\n for i in matrix.OPs:\\n seed.append(i)\\n centroids = cluster(old_ops, seed, mut)\\n disto = distortion(centroids, old_ops, mut)\\n\\n return centroids, disto\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def kmeans(bboxes, k, dist=np.median):\\n rows = bboxes.shape[0]\\n\\n distances = np.empty((rows, k))\\n last_clusters = np.zeros((rows,))\\n\\n np.random.seed()\\n\\n # the Forgy method will fail if the whole array contains the same rows\\n clusters = bboxes[np.random.choice(rows, k, replace=False)]\\n\\n while True:\\n for row in range(rows):\\n distances[row] = 1 - iou(bboxes[row], clusters)\\n\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n for cluster in range(k):\\n clusters[cluster] = dist(bboxes[nearest_clusters == cluster], axis=0)\\n\\n last_clusters = nearest_clusters\\n\\n return clusters\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def cluster_rgbxy(im,k, lambda_1 = 0.5, lambda_2 = 0.5):\\n print(\\\"Starting RGBXY K-Means algorithm...\\\")\\n # convert BGR to RGB\\n # im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n h, w, d = np.shape(im)\\n im_vector = im.reshape((-1, 3))\\n arr = [[[j, i] for i in range(w)] for j in range(h)]\\n arr = np.asarray(arr)\\n im_vector_xy = arr.reshape((-1, 2))\\n # cluster_centers ~ initialization\\n\\n # pick random x and y and choose their rgb value\\n np.random.seed(100)\\n cluster_centers_xy = [np.random.choice(h, k), np.random.choice(w, k)]\\n cluster_centers_xy = np.asarray(cluster_centers_xy)\\n cluster_centers_xy.reshape((k, -1))\\n cluster_centers_xy = cluster_centers_xy.transpose()\\n # cluster_centers_rgb = [[im[cluster[0]][cluster[1]] for cluster in cluster_centers_xy]]\\n cluster_centers_rgb = []\\n for cluster in cluster_centers_xy:\\n cluster_centers_rgb.append(im[cluster[0]][cluster[1]])\\n cluster_centers_rgb = np.asarray(cluster_centers_rgb)\\n # cluster_centers_rgb = im[cluster_centers_xy[:, 0], cluster_centers_xy[:, 1]]\\n # cluster_centers = (np.random.choice(255, k*3)).reshape((-1,3))\\n\\n # dist = np.linalg.norm( np.tile(im_vector[0] , (k,1)) - cluster_centers, axis=1)\\n # dist = np.linalg.norm( np.repeat(im_vector, repeats=k, axis=0) - np.tile(cluster_centers , (len(im_vector),1)), axis=1 )\\n # dist = dist.reshape(len(dist),-1)\\n\\n im_vec_dist = np.repeat(im_vector, repeats=k, axis=0)\\n im_vec_dist = np.array(im_vec_dist, dtype=np.int16)\\n im_vec_dist_xy = np.repeat(im_vector_xy, repeats=k, axis=0)\\n im_vec_dist_xy = np.array(im_vec_dist_xy, dtype=np.int16)\\n distance_moved = float('inf')\\n # convergence threshold\\n thresh = 20\\n if (k >= 10):\\n thresh = 20\\n if (k >= 25):\\n thresh = 45 # 50\\n if (k >= 50):\\n thresh = 85 # 90\\n if (k >= 100):\\n thresh = 300\\n if (k >= 250):\\n thresh = 430\\n final_cluster_points = 0\\n\\n while (distance_moved > thresh):\\n\\n # initialize empty cluster bins\\n cluster_points = []\\n for i in range(k):\\n cluster_points.append([])\\n\\n dist_rgb = np.linalg.norm(im_vec_dist - np.tile(cluster_centers_rgb, (len(im_vector), 1)), axis=1)\\n dist_xy = np.linalg.norm(im_vec_dist_xy - np.tile(cluster_centers_xy, (len(im_vector_xy), 1)), axis=1)\\n\\n dist = lambda_1 * dist_rgb + lambda_2 * dist_xy\\n\\n # allocate cluster center to each pixel\\n it = 0\\n for i in range(0, len(dist), k):\\n current_dist = dist[i: i + k]\\n min_value = min(current_dist)\\n min_position = np.argmin(current_dist)\\n # segregate the points in k bins\\n # append point index\\n cluster_points[min_position].append(it)\\n it += 1\\n\\n # recompute cluster centers\\n distance_moved = 0\\n for i in range(k):\\n cp = cluster_points[i]\\n # get points\\n a = im_vector[cp]\\n b = im_vector_xy[cp]\\n if (len(a)):\\n new_centers = a.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_rgb[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_rgb[i] = new_centers\\n if (len(b)):\\n new_centers = b.mean(axis=0)\\n distance_moved += np.linalg.norm(cluster_centers_xy[i] - new_centers)\\n # update new cluster centers\\n cluster_centers_xy[i] = new_centers\\n\\n # for cp in cluster_points:\\n # print(np.shape(cp))\\n\\n final_cluster_points = cluster_points\\n\\n print(distance_moved)\\n\\n index_vector = np.empty([len(im_vector), 1])\\n # cp is the point instances\\n for i in range(k):\\n cp = final_cluster_points[i]\\n # print(np.shape(cp))\\n index_vector[cp] = i\\n segmap = index_vector.reshape((h, w))\\n # print(segmap)\\n # print(np.shape(segmap))\\n # at every location, put the corresponding cluster number\\n # segmap = np.empty()\\n # segmap is nXm. Each value in the 2D array is the cluster assigned to that pixel\\n return segmap\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def kmeans(self,initial_centers=None,tolerance=0):\\r\\n\\t\\tcenters = initial_centers \\\\\\r\\n\\t\\t\\t\\tif initial_centers is not None else self.centers()\\r\\n\\t\\t\\r\\n\\t\\titerations = 0\\r\\n\\t\\twhile True:\\r\\n\\t\\t\\titerations = iterations + 1\\r\\n\\t\\t\\tclusters = dict([(i,[]) for i in xrange(self.k)])\\r\\n\\t\\t\\tfor a in self.data:\\r\\n\\t\\t\\t\\tcc = self.closest_center(centers, a)\\r\\n\\t\\t\\t\\tcenter = cc[0]\\r\\n\\t\\t\\t\\tlabel = center[0]\\r\\n\\t\\t\\t\\tclusters[label].append(a)\\r\\n\\r\\n\\t\\t\\tfor label, data_points in clusters.iteritems():\\r\\n\\t\\t\\t\\tif not data_points:\\r\\n\\t\\t\\t\\t\\tcenters = self.centers()\\r\\n\\t\\t\\t\\t\\tbreak # restart at random\\r\\n\\r\\n\\t\\t\\t\\tcenter = centers[label]\\r\\n\\t\\t\\t\\told_center_x, old_center_y = center[1], center[2]\\r\\n\\t\\t\\t\\tnew_center_x, new_center_y = self.mean(data_points)\\r\\n\\r\\n\\t\\t\\t\\tif abs(new_center_x - old_center_x) <= tolerance \\\\\\r\\n\\t\\t\\t\\t\\t\\tand abs(new_center_y - old_center_y) <= tolerance:\\r\\n\\t\\t\\t\\t\\t# converged\\r\\n\\t\\t\\t\\t\\treturn {\\r\\n\\t\\t\\t\\t\\t\\t\\t'iterations' : iterations,\\r\\n\\t\\t\\t\\t\\t\\t\\t'clusters' : clusters, \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t'centers' : centers }\\r\\n\\r\\n\\t\\t\\t\\t# update center to mean\\r\\n\\t\\t\\t\\tcenter[1] = new_center_x\\r\\n\\t\\t\\t\\tcenter[2] = new_center_y\",\n \"def _init_homolog_centers(self, method=\\\"kmeans\\\", min_spot_num=2, axis_infos=Axis3D_infos):\\n if hasattr(self, 'chr_2_homolog_centers') and not self.overwrite:\\n if self.verbose:\\n print(f\\\"- directly return chr_2_homolog_centers\\\")\\n return\\n if method == 'kmeans':\\n from sklearn.cluster import KMeans\\n # chr_2_init_centers\\n self.chr_2_homolog_centers = {}\\n self.chr_2_cand_hzxys = {}\\n self.chr_2_cand_ids = {}\\n # loop through chrs\\n for _chr_name, _exp_num in self.chr_2_copyNum.items():\\n _chr_coords_df = self.merged_coords.loc[self.merged_coords['chr']==str(_chr_name)]\\n # if not spots exists, skip\\n if len(_chr_coords_df) < min_spot_num:\\n continue\\n # get coordinates\\n _chr_hzxys = _chr_coords_df[['center_intensity']+[f\\\"center_{_x}\\\" for _x in axis_infos]].values\\n _chr_ids = _chr_coords_df['chr_order'].values\\n # append\\n self.chr_2_cand_hzxys[_chr_name] = _chr_hzxys\\n self.chr_2_cand_ids[_chr_name] = _chr_ids\\n # calculate weights\\n _uinds, _uind_counts = np.unique(_chr_ids, return_counts=True)\\n _ind_2_weight = {_i:1/_c for _i,_c in zip(_uinds, _uind_counts)}\\n _chr_weights = np.array([_ind_2_weight[_i] for _i in _chr_ids])\\n # K-means\\n if method =='kmeans':\\n _model = KMeans(n_clusters=_exp_num, random_state=0)\\n _model.fit(_chr_hzxys[:,1:], sample_weight=_chr_weights)\\n #_init_labels = _model.labels_\\n _init_centers = _model.cluster_centers_\\n # save for now\\n self.chr_2_homolog_centers[_chr_name] = _init_centers\",\n \"def gen_random_clusters(num_clusters):\\n cluster_list = []\\n\\n for county_id in range(num_clusters):\\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\\n return cluster_list\",\n \"def __initialise_smart(self, X, args):\\n\\t\\tcentroids = np.zeros((self.K,self.D))\\n\\t\\tif X.shape[0] > 10*self.K:\\n\\t\\t\\tdata = X[:10*self.K,:]\\n\\t\\telse:\\n\\t\\t\\tdata = X\\n\\t\\tN = data.shape[0]\\n\\n\\t\\t\\t#choosing centroids\\n\\t\\t\\t#points are chosen from dataset with farhtest point clustering\\n\\t\\tran_index = np.random.choice(N)\\n\\t\\tcentroids[0,:] = data[ran_index]\\n\\n\\t\\tfor k in range(1,self.K):\\n\\t\\t\\tdistances = np.zeros((N,k)) #(N,K)\\n\\t\\t\\tfor k_prime in range(k):\\n\\t\\t\\t\\tdistances[:,k_prime] = np.sum(np.square(data - centroids[k_prime,:]), axis =1) #(N,K')\\n\\t\\t\\tdistances = np.min(distances, axis = 1) #(N,)\\n\\t\\t\\tdistances /= np.sum(distances) #normalizing distances to make it a prob vector\\n\\t\\t\\tnext_cl_arg = np.random.choice(range(data.shape[0]), p = distances) #chosen argument for the next cluster center\\n\\t\\t\\tcentroids[k,:] = data[next_cl_arg,:]\\n\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.sum(np.divide(np.square(X - centroids[k,:]), var), axis = 1) + 1e-5\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def c_centers(self):\\n self.compute_c_centers(self)\\n return self._c_centers\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def test_one_center(self):\\n sv=system_vars_c().init_xyzlike([ [8, [0.0, 0.0, 0.0]]])\\n atom2rcut=np.array([5.0])\\n g = dft.gen_grid.Grids(sv)\\n g.level = 1 # precision as implemented in pyscf\\n g.radi_method=leggauss_ab\\n g.build(atom2rcut=atom2rcut)\\n\\n #print( max( np.linalg.norm(g.coords, axis=1) ) )\\n #print( g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0 )\\n self.assertAlmostEqual(max( np.linalg.norm(g.coords, axis=1) ), 4.9955942742763986)\\n self.assertAlmostEqual(g.weights.sum(), 4.0 *np.pi*5.0**3 / 3.0)\\n self.assertEqual(len(g.weights), 6248)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7741881","0.73474836","0.7212278","0.69355553","0.68558514","0.67842954","0.67727154","0.6745349","0.67441016","0.6541365","0.65011424","0.6499605","0.6450051","0.63159925","0.6306321","0.6281557","0.6235609","0.6231545","0.62127733","0.6210027","0.62074447","0.62074447","0.61994135","0.6149112","0.61379296","0.6137604","0.6136791","0.6128657","0.61242086","0.6113311","0.61112374","0.6109535","0.6108615","0.60978985","0.6092544","0.60905725","0.60849756","0.60612935","0.6048567","0.6005958","0.5980971","0.596201","0.59593934","0.5957475","0.5948076","0.5945751","0.5928573","0.59244156","0.5922932","0.59044254","0.5901207","0.58975285","0.5875528","0.58733577","0.58712345","0.58519274","0.5850776","0.5839685","0.5832303","0.58274466","0.5813466","0.58077013","0.5804017","0.5765343","0.57598525","0.5759151","0.5749517","0.57489556","0.5745694","0.5734387","0.572637","0.57229125","0.5722772","0.57076323","0.57018507","0.56933093","0.56882596","0.5685517","0.56804866","0.567996","0.5677602","0.5676258","0.5674419","0.5670971","0.56642056","0.564732","0.5645801","0.56455743","0.56425756","0.5641828","0.5632408","0.5627707","0.5622451","0.56048274","0.5600421","0.5600258","0.5588445","0.5587156","0.55806285","0.55745"],"string":"[\n \"0.7741881\",\n \"0.73474836\",\n \"0.7212278\",\n \"0.69355553\",\n \"0.68558514\",\n \"0.67842954\",\n \"0.67727154\",\n \"0.6745349\",\n \"0.67441016\",\n \"0.6541365\",\n \"0.65011424\",\n \"0.6499605\",\n \"0.6450051\",\n \"0.63159925\",\n \"0.6306321\",\n \"0.6281557\",\n \"0.6235609\",\n \"0.6231545\",\n \"0.62127733\",\n \"0.6210027\",\n \"0.62074447\",\n \"0.62074447\",\n \"0.61994135\",\n \"0.6149112\",\n \"0.61379296\",\n \"0.6137604\",\n \"0.6136791\",\n \"0.6128657\",\n \"0.61242086\",\n \"0.6113311\",\n \"0.61112374\",\n \"0.6109535\",\n \"0.6108615\",\n \"0.60978985\",\n \"0.6092544\",\n \"0.60905725\",\n \"0.60849756\",\n \"0.60612935\",\n \"0.6048567\",\n \"0.6005958\",\n \"0.5980971\",\n \"0.596201\",\n \"0.59593934\",\n \"0.5957475\",\n \"0.5948076\",\n \"0.5945751\",\n \"0.5928573\",\n \"0.59244156\",\n \"0.5922932\",\n \"0.59044254\",\n \"0.5901207\",\n \"0.58975285\",\n \"0.5875528\",\n \"0.58733577\",\n \"0.58712345\",\n \"0.58519274\",\n \"0.5850776\",\n \"0.5839685\",\n \"0.5832303\",\n \"0.58274466\",\n \"0.5813466\",\n \"0.58077013\",\n \"0.5804017\",\n \"0.5765343\",\n \"0.57598525\",\n \"0.5759151\",\n \"0.5749517\",\n \"0.57489556\",\n \"0.5745694\",\n \"0.5734387\",\n \"0.572637\",\n \"0.57229125\",\n \"0.5722772\",\n \"0.57076323\",\n \"0.57018507\",\n \"0.56933093\",\n \"0.56882596\",\n \"0.5685517\",\n \"0.56804866\",\n \"0.567996\",\n \"0.5677602\",\n \"0.5676258\",\n \"0.5674419\",\n \"0.5670971\",\n \"0.56642056\",\n \"0.564732\",\n \"0.5645801\",\n \"0.56455743\",\n \"0.56425756\",\n \"0.5641828\",\n \"0.5632408\",\n \"0.5627707\",\n \"0.5622451\",\n \"0.56048274\",\n \"0.5600421\",\n \"0.5600258\",\n \"0.5588445\",\n \"0.5587156\",\n \"0.55806285\",\n \"0.55745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7343511"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":9493,"cells":{"query":{"kind":"string","value":"Create random cluster centers. Create n cluster centers randomly. Each cluster center is a draw from a gaussian distribution centered at (0,0) with standard covariance."},"document":{"kind":"string","value":"def _random_standard_centers(n=100):\n generator = mn(mean=np.array([0, 0]),\n cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))\n for pt in generator.rvs(size=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 make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n centroids = np.array(zip(*centroids))\n\n points = []\n for centroid in centroids:\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\n points.append(rands)\n\n return np.array(points).reshape(-1, 2)","def random_centers(k,):\n #centr = np.random.random((k, pos.shape[1]))\n return","def init_cluster_centroids(x, number_of_clusters):\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]","def randCent(data,k):\n index = set()\n while len(index) != k:\n index.add(random.randint(0, data.shape[0]))\n index = list(index)\n centroids = data[index]\n return centroids","def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\n\t\t\t\t\t\tflag = False\n\t\t\tcenters.append(c)\n\t\t\t\t\n\t\treturn centers","def initialize_centers(data, k):\n x_data_min = min(p[0] for p in data)\n x_data_max = max(p[0] for p in data)\n y_data_min = min(p[1] for p in data)\n y_data_max = max(p[1] for p in data)\n\n return generate_random_data(\n k,\n x_data_min,\n x_data_max,\n y_data_min,\n y_data_max\n )","def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroids","def gen_random_clusters(num_clusters):\n clusters = []\n\n for _ in xrange(num_clusters):\n clusters.append(alg_cluster.Cluster(\n set(),\n random.randint(-1, 1),\n random.randint(-1, 1),\n 0,\n 0\n ))\n return clusters","def gen_k_centers(k, dim):\n delta = abs(np.random.normal(0.0, 5.0))\n eps = 0.001\n centers = []\n for i in range(k):\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\n if len(centers):\n c1 = centers[0]\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\n direction = x / np.linalg.norm(x)\n centers.append(c1 + 2.0 * i * delta * direction + eps)\n else:\n centers.append(c)\n return centers, delta","def get_random_centroids(data, k) :\r\n centroids = []\r\n columns = np.size(data, axis=1)\r\n ranges = []\r\n for i in range(columns) :\r\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\r\n \r\n for i in range(k) :\r\n centroid = []\r\n for span in ranges :\r\n centroid.append(np.random.uniform(span[0], span[1]))\r\n centroids.append(centroid)\r\n \r\n return np.matrix(centroids)","def gen_random_clusters(num_clusters):\n\t\tcluster_list = []\n\t\tlower_bound = -1\n\t\tupper_bound = 1\n\t\trange_width = upper_bound - lower_bound\n\t\tfor idx in range(num_clusters):\n\t\t\tx_val = random.random() * range_width + lower_bound\n\t\t\ty_val = random.random() * range_width + lower_bound\n\t\t\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\n\t\treturn cluster_list","def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\n point_list = []\n for rand in rands:\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n counter = 0\n while counter < points_per_cluster:\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\n new_point = np.append(nearCluster, nearClusterLastItem)\n # radius of hyperbolic ball is 0.2\n if hyperboloidDist(new_point, rand) < .2:\n point_list.append(new_point)\n counter += 1\n\n return np.array(point_list)","def initialize_clusters(points, k):\r\n return points[np.random.randint(points.shape[0], size=k)]","def clusterize(x, n):\n if n == 1:\n return np.zeros(x.shape[0])\n elif n > 1:\n kmeans = KMeans(n_clusters=n).fit(x)\n return kmeans.predict(x)\n else:\n raise ValueError(\"set n_spheres > 0\")","def generateClusterPoints(N, k=2, scale=1):\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\n point_list = []\n for rand in rands:\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\n lastItem = math.sqrt(1 + np.dot(rand, rand))\n rand.append(lastItem)\n point_list.append(rand)\n return np.array(point_list)","def generate_initial_centroids(k, data):\n centroids = []\n used_indexes = []\n while len(centroids) < k:\n random_index = random.randint(0, len(data) - 1)\n if random_index not in used_indexes:\n centroids.append(data[random_index])\n used_indexes.append(random_index)\n return centroids","def gen_random_clusters(num_clusters):\n cluster_list = []\n\n for county_id in range(num_clusters):\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\n return cluster_list","def recalculate_centers(data, k, clusters):\n centers = []\n for k_i in range(k):\n inds = [i for i, j in enumerate(clusters) if j == k_i]\n n = np.take(data, inds, axis=0)\n if len(inds) == 0:\n i = np.random.randint(len(data))\n centers.append((data[i,0], data[i,1]))\n\n elif len(inds) < 2: \n centers.append((n[0][0], n[0][1]))\n else:\n result = np.sum(n, axis=1)/len(inds)\n centers.append((result[0], result[0]))\n return centers","def getRandomCentroids(data_points, k):\n return random.sample(data_points, k)","def init_centroids(self, points , k):\n centroids = points.copy()\n numpy.random.shuffle(centroids)\n return centroids[0:k,:]","def creaCent(data,k):\n\n Cen = random.sample(data[:,:].tolist(),k=k)\n return np.asarray(Cen)","def setup_rand_gmm(n_components=3, n_features=10,\n clust_mean_std=2.0,\n cluster_std=1.0,\n cov_how='diag',\n weights_how='uniform',\n random_state=None):\n\n rng = check_random_state(random_state)\n\n ##########################\n # generate cluster means #\n ##########################\n\n # cluster means are generated from a spherical gaussian\n center_cov = np.eye(n_features) * clust_mean_std ** 2\n means = rng.multivariate_normal(mean=np.zeros(n_features),\n cov=center_cov,\n size=n_components)\n\n ################################\n # generate cluster covariances #\n ################################\n\n if cov_how.lower() == 'diag':\n # diagonal covariances\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\n for _ in range(n_components)])\n elif cov_how.lower() == 'wishart':\n raise NotImplementedError # TODO-FEAT: implement this!\n else:\n raise ValueError(\"cov_how must be one of ['diag', 'wishart']\"\n \"not {}\".format(cov_how))\n\n ############################\n # generate cluster weights #\n ############################\n if weights_how.lower() == 'uniform':\n weights = rng.dirichlet(np.ones(n_components))\n elif weights_how.lower() == 'random':\n weights = np.ones(n_components) / n_components\n else:\n raise ValueError(\"weights_how must be one of ['random', 'uniform']\"\n \"not {}\".format(weights_how))\n\n return means, covariances, weights","def initialize_dom(img: np.ndarray):\n\n channels = img.shape[2]\n\n for cluster in range(numclusters):\n for channel in range(channels):\n cmin = np.amin(img[:,:,channel]) # channel's min\n cmax = np.amax(img[:,:,channel]) # channel's max\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\n dimensions=CLUSTER_DEFAULTS['dimensions']):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n image = gaussian_filter(image, sigma=1)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def initialize(img):\n w, h, _ = img.shape\n for c in current_cluster_centers:\n x = np.random.randint(w)\n y = np.random.randint(h)\n c[:] = img[x, y]","def init_centroids(X,K):\n c = random.sample(list(X),K)\n return c","def initialize_pos(img: np.ndarray):\n\n h, w = img.shape[0:2]\n\n for cluster in range(numclusters):\n i = np.random.randint(h) # row index\n j = np.random.randint(w) # col index\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\n\n # Initialize some empty lists to receive cluster member positions\n testClustersx = []\n testClustersy = []\n # Genereate random values given parameter ranges\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\n\n # Generate random clusters given parameter values\n for idx, npts in enumerate(n_points):\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\n testClustersx.append(xpts)\n testClustersy.append(ypts)\n\n # Convert to a single dataset in OpenCV format\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\n\n # Return cluster positions\n return testClusters, testClustersx, testClustersy","def _get_init_centers(n_clusters, samples):\n # randomly choose one initial sequence as the first center\n init_ids = [0]\n init_sequence = samples[0][0] # sequence\n all_distances = []\n # the idea is to choose medoids far away from each other\n for _ in range(1, len(samples)):\n current_seq = samples[_][0]\n all_distances.append((_, distance_measuring(init_sequence, current_seq)))\n arranged = sorted(all_distances, key=get_key, reverse=True) # descending order\n arranged_ids = [_[0] for _ in arranged]\n init_ids += arranged_ids[:n_clusters - 1]\n return init_ids","def __get_initial_centroid(self, x_train, seed=None):\n if self.init == \"random\":\n # randomly select n_cluster point from the input dataset\n if seed:\n random.seed(seed)\n return np.asarray(random.choices(x_train, k=self.n_cluster))","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def initialize_pp(img: np.ndarray):\n\n h, w, c = img.shape\n pixels = img.copy().reshape(h*w, c)\n\n # Choose one center uniformly at random \n # from among the data points\n r = np.random.randint(h*w)\n current_cluster_centers[0, 0, :] = pixels[r, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, r, axis=0)\n\n # For each data point x, compute D(x), \n # the distance between x and the nearest center \n # that has already been chosen.\n for k in range(1, numclusters):\n dist_sq = np.zeros(pixels.shape[0])\n for i in range(pixels.shape[0]): # over data points\n dist = []\n for j in range(k): # over current clusters\n # calculate distance to the cluster\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\n dist.append(np.inner(diff, diff))\n \n # choose the distance closest to the cluster\n dist_sq.itemset(i, min(dist))\n\n probs = dist_sq / dist_sq.sum()\n cumprobs = probs.cumsum()\n r = np.random.uniform()\n for i, prob in enumerate(cumprobs):\n if r <= prob:\n index = i\n break\n \n # add a new cluster\n current_cluster_centers[k, 0, :] = pixels[index, :]\n\n # remove that point from the data set\n pixels = np.delete(pixels, index, axis=0)\n\n\n print(\"Current clusters:\\n\", current_cluster_centers)","def _initiate_random_centroids(all_features, vocab_size):\n centroids = []\n # 1) Genereate points for initial centroids\n\n min_feat = np.ones(all_features[0].size)*np.inf\n max_feat = np.zeros(all_features[0].size)\n\n for a in all_features:\n for p in range(len(a)):\n if a[p] < min_feat[p]:\n min_feat[p] = a[p]\n else:\n if a[p] > max_feat[p]:\n max_feat[p] = a[p]\n\n\n for _ in range(vocab_size):\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\n max_feat-min_feat) + min_feat\n centroids.append(random_vector.flatten())\n\n return np.array(centroids)","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def random_cluster_matrix(shape):\n N, k = shape\n A = np.zeros((N, k))\n for row in A: \n row[randint(0, k - 1)] = 1\n\n return A","def recenter(self, n):\n clustering = self\n for i in xrange(n):\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\n consensus_threshold=clustering.consensus_threshold)\n return clustering","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def clusterGen(k, colors):\n clusters = []\n # generate the clusters randomly\n # for i in range(k):\n # r = random.randint(0, 255)\n # g = random.randint(0, 255)\n # b = random.randint(0, 255)\n # clusters.append((r, g, b))\n\n # generate the clusters that exist in colors\n l = len(colors)\n for i in range(k):\n r = random.randint(0, l)\n cluster = colors[r][1]\n clusters.append(cluster)\n\n return clusters","def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\n\n nx, ny = dimensions\n\n # Create empty image\n image = np.zeros((ny, nx))\n\n # Generate random positions\n r = np.random.random(n_stars) * nx\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\n\n # Generate random fluxes\n fluxes = np.random.random(n_stars) ** 2\n\n # Compute position\n x = nx / 2 + r * np.cos(theta)\n y = ny / 2 + r * np.sin(theta)\n\n # Add stars to image\n # ==> First for loop and if statement <==\n for idx in range(n_stars):\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\n image[y[idx], x[idx]] += fluxes[idx]\n\n # Convolve with a gaussian\n kernel = Gaussian2DKernel(stddev=1)\n image = convolve_fft(image, kernel)\n\n # Add noise\n image += np.random.normal(1., 0.001, image.shape)\n\n return image","def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\n\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\n\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\n\n\tax = plt.gca()\n\t#for i in range(points.shape[1]):\n\t\t#plt.plot(points[:, i][0], points[:, i][1], \".\", color=\"r\", zorder=0)\n\tplt.plot(points[0], points[1], \".\", color=\"r\", zorder=0)\n\t\n\tfor i in range(gaussians):\n\t\tplt.plot(c_means[i][0], c_means[i][1], \".\", color=colors[i], zorder=1)\n\n\t\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\n\t\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\n\t\t\t\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\n\t\t\t\t\t\tzorder=4)\n\n\t\tax.add_patch(ellipse)\n\t\n\tplt.savefig(\"./images/{0}/{1:08d}.png\".format(test_name, image_num))\n\tplt.close()","def create_clusters(N, K):\n clusters = []\n centroids = create_points(N, K)\n for idx, centroid in enumerate(centroids):\n cluster = Cluster(centroid)\n cluster.label = _cluster_name(idx)\n clusters.append(cluster)\n return clusters","def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in range(self.K):\n indexes = np.argwhere(distances == i)\n data = self.vectors[indexes.transpose()[0]]\n if data.shape[0] > 1:\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\n else:\n new_clusters[i] = np.sum(data, axis=0)\n print ex, '----', self.cal_purity()\n ex += 1\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\n break\n self.centroids = new_clusters","def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\n\n if random_state is not None: np.random.seed(random_state)\n\n n_samples = n_samples//n_cluster\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\n\n for cluster_idx in range(n_cluster):\n # Group indicator\n #group = sp.binom.rvs(p=0.25, n=1, size=N\n n_neg = int(n_samples*(1-pos_ratio))\n n_pos = n_samples-n_neg\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\n\n idx_dependent = n_var - n_dependent\n\n if mean is None:\n basic_mean = 0 #np.random.uniform(size=no_var)\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\n else:\n mean0 = mean[cluster_idx][0]\n mean1 = mean[cluster_idx][1]\n \n\n # # Noise are variables with same distribution in majority and minority class\n # if noise_ratio != 0:\n # n_noise = int(noise_ratio*n_var)\n # noise_idx = n_var - n_noise\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\n # size=n_samples).reshape([n_samples,-1])\n \n cov0, cov1 = None, None\n\n X1 = []\n X0 = []\n # Independent variables\n if n_var-n_dependent > 0:\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\n\n # Dependent variables\n if n_dependent>0:\n if cov is None:\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\n else:\n cov0 = cov[cluster_idx][0]\n cov1 = cov[cluster_idx][1]\n\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\n cov= cov1, size=n_pos)\n )\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\n cov= cov0, size=n_neg)\n )\n \n X0 = np.hstack([*X0])\n X1 = np.hstack([*X1])\n X_cluster.append(np.vstack([X0, X1]))\n #X = np.hstack([X, X_noise])\n\n mean0_cluster.append(mean0)\n mean1_cluster.append(mean1)\n cov0_cluster.append(cov0)\n cov1_cluster.append(cov1)\n\n if n_cluster == 1:\n X = X_cluster[0]\n y = y_cluster[0]\n else:\n X = np.vstack(X_cluster)\n y = np.hstack(y_cluster)\n\n #return {\"X\":X, \"y\":y,\"mean0\":mean0,\"mean1\":mean1, \"cov0\":cov0, \"cov1\":cov1}\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster","def initialize(X, k):\n\n if not isinstance(X, np.ndarray) or X.ndim != 2:\n return None\n\n # n: number of dada points\n # d: dimension of each data point\n n, d = X.shape\n # print(X.shape)\n # print(X)\n\n if not isinstance(k, int) or k <= 0 or k > n:\n return None\n\n # Sample k centroids from a random.uniform distribution;\n # output is an array of coordinates\n C = np.random.uniform(low=np.min(X, axis=0),\n high=np.max(X, axis=0),\n size=(k, d))\n return C","def create_gaussian_data(self, mean, std, nPoints, nClusters, nDimension):\n dataset = np.zeros((nClusters, nPoints, nDimension), dtype=float)\n for i in range(nClusters):\n cov = std[i] ** 2\n dataset[i, :, :] = np.random.multivariate_normal(mean[i], cov, nPoints)\n\n return dataset","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points","def generate_k(data_set, k):\n centers = []\n dimensions = len(data_set[0])\n min_max = defaultdict(int)\n\n for point in data_set:\n for i in range(dimensions):\n val = point[i]\n min_key = 'min_{0}d'.format(i)\n max_key = 'max_{0}d'.format(i)\n if min_key not in min_max or val < min_max[min_key]:\n min_max[min_key] = val\n if max_key not in min_max or val > min_max[max_key]:\n min_max[max_key] = val\n\n for _k in range(k):\n rand_point = []\n for i in range(dimensions):\n min_val = min_max['min_{0}d'.format(i)]\n max_val = min_max['max_{0}d'.format(i)]\n \n rand_point.append(uniform(min_val, max_val))\n centers.append(rand_point)\n return centers","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))","def generate_tensor(shape, cluster_count=3, cluster_radius=3, low=0, high=255, eps=10, dtype=np.int32):\n\n tensor = np.zeros(shape, dtype)\n\n clusters = []\n for i in range(cluster_count + 1):\n cluster = {}\n\n coordinates = []\n for dim in shape:\n coordinate = np.random.randint(0, high=dim)\n coordinates.append(coordinate)\n\n cluster['coordinates'] = coordinates\n coordinates = tuple(coordinates)\n\n mask = generate_mask(shape, coordinates, cluster_radius)\n\n point_value = np.random.randint(low=low, high=high, size=1)[0]\n point_value = int(point_value)\n\n cluster['center_value'] = point_value\n cluster['radius'] = cluster_radius\n\n random_values = np.random.randint(low=point_value-eps, high=point_value+eps+1, size=shape)\n random_values_masked = np.ma.array(random_values, mask=np.logical_not(mask))\n\n idx = (mask > 0)\n tensor[idx] = random_values_masked[idx]\n clusters.append(cluster)\n\n return tensor, clusters","def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(10)\n for j in range(10)]","def generate_parameters(self, cluster_center, std_dev, num_tasks):\n return np.random.normal(cluster_center, std_dev, num_tasks)","def initialize_centroids(X, K):\n idx = np.random.choice(X.shape[0], K, replace = False)\n centroids = X[idx,:]\n return centroids","def create_dataset(n_clusters, n_dim, n_samples, mean=None, std=None, seed=None):\n if seed is not None:\n np.random.seed(seed)\n\n if mean is None:\n means = [np.random.randint(-(i + 1), (i + 1),\n n_dim).astype(np.float32) for i in range(n_clusters)]\n if std is None:\n stds = []\n for _ in range(n_clusters):\n a = np.diag(random.rand(n_dim))\n stds.append(a)\n\n data_set = []\n cluster_id = []\n for i, mean, std in zip(range(n_clusters), means, stds):\n data_set.append(np.random.multivariate_normal(mean, std, n_samples))\n cluster_id.append(np.ones(n_samples) * i)\n\n data_set = np.concatenate(data_set)\n cluster_id = np.concatenate(cluster_id)\n sample_idx = np.random.choice(data_set.shape[0], n_samples, replace=False)\n\n # Return correct amount of samples\n return data_set[sample_idx, :], cluster_id[sample_idx]","def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\n file_path=None, save_name=None, device='cpu'):\n\n if file_path: # Load centers from file and return them on device\n print(\"Loading pretrained KMeans centroids\")\n centers = np.loadtxt(file_path)\n cluster_centers = torch.tensor(\n centers, dtype=torch.float, requires_grad=True).to(device)\n else: # Train Kmeans and generate centers\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\n print(\"Training KMeans for centroids\")\n kmeans = KMeans(n_clusters=cluster_number,\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\n autoencoder.eval()\n features = []\n actual = []\n\n # merge dataloaders\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\n\n dataloader = torch.utils.data.DataLoader(\n dataset=concat_dataset,\n batch_size=args.encoder_bs\n )\n\n # form initial cluster centres\n data_iterator = tqdm(dataloader,\n leave=True,\n unit=\"batch\",\n disable=False,\n )\n print(\"Generating features for kmeans\")\n\n with torch.no_grad():\n # Loop through data and generate features from the encoder. \n for index, batch in enumerate(data_iterator):\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\n # if we have a prediction label, separate it to actual\n batch, value = batch\n actual.append(value)\n # Assuming we use the encoder from module.py\n if args.encoder_type == 'vae':\n feature = autoencoder(batch.to(device))\n elif args.encoder_type == 'resnet50':\n feature = list()\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\n\n feature.append(z)\n\n features.append(feature[0].detach().cpu())\n print(\"Training samples:\", len(features))\n\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\n samples = torch.cat(features)\n print(f\"Data shape {samples.shape}\")\n print(f\"Labels shape {actual.shape}\")\n print(\"Training...\")\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\n cluster_centers = kmeans.cluster_centers_ # define centers\n\n if save_name: # If param. save_name then save the centers.\n filepath = args.log_dir + save_name + \".txt\"\n if not os.path.exists(args.log_dir):\n os.mkdir(args.log_dir)\n print(\"Saving clusters to:\", filepath)\n np.savetxt(filepath, cluster_centers)\n if not (wandb.run is None): # check if wandb is running\n wandb.run.summary[f\"{save_name}_accuracy\"] = accuracy\n\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\n cluster_centers, dtype=torch.float, requires_grad=True\n ).to(device)\n print(f\"Training KMeans completed, accuracy: {accuracy:.2f}\")\n return cluster_centers","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n # position initial clusters at the location of clusters with largest populations\n cluster_list_copy = sorted(cluster_list,\n reverse = True,\n key=lambda cluster: cluster.total_population())\n cluster_list_copy = cluster_list_copy[: num_clusters]\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\n result = []\n #clustering to k initial centers adjusting the centers after each iteration\n for dummy_q in range(num_iterations):\n #Initialize k empty sets C1,...,Ck\n k_clusters = []\n for dummy_k in range(num_clusters):\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n for idx_j in range(len(cluster_list)):\n # defining the closest k center and add the cluster to it\n dist_list = []\n for idx_k in range(num_clusters):\n center_x, center_y = cluster_cent[idx_k]\n dist = cluster_list[idx_j].distance(\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\n dist_list.append((dist, idx_k))\n dummy_k, idx = min(dist_list)\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\n result = k_clusters\n #update the new center of k clusters\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\n return result","def cluster_centers(X, k, bounds):\n\n mu = random_plane_points(k, bounds)\n kmeans = sklearn.cluster.KMeans(init=mu)\n kmeans.fit(X)\n\n # Restart if a mean has no associated points\n if len(set(kmeans.labels_)) < k:\n return cluster_centers(X, k, bounds)\n\n return kmeans.cluster_centers_","def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]","def kMeans(d, k):\n #First get the random centroids from the data\n newCentroids = getRandomCentroids(d, k)\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\n\n #Get the clusters from these random centroids\n clusters = initiateCentroid(d, newCentroids, k)\n oldCentroids = []\n\n counter = 0\n #While the old centroids are not equal to the new ones\n while oldCentroids != newCentroids:\n #old is equal to new\n oldCentroids = newCentroids\n #Calculate the new centroids\n k, newCentroids = calcCentroids(d, clusters)\n #Calculate the new clusters\n clusters = initiateCentroid(d, newCentroids, k)\n #Count how many iterations\n counter += 1\n\n return counter, clusters","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def centers(pos):\n number_of_nodes = len(pos)\n ε, δ = 0.03, 0.1\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\n k = int(np.sqrt(r))\n k = np.min((k, number_of_nodes))\n \n return k_means_pp(k, pos)","def random_spherepos(n):\n signs = np.sign(rand.uniform(-1,1,size=n))\n thetas = Angle(np.arccos(rand.uniform(size=n)*signs),unit=u.rad) #random b/w 0 and 180\n phis = Angle(rand.uniform(0,2*np.pi,size=n),unit=u.rad)\n c = SkyCoord(phis,thetas,1,representation='physicsspherical')\n return c","def random_assignment_of_clusters(self, data):\n return np.random.randint(low=0, high=self.n_clusters, size=len(data[:, 0]))","def random_k_means(d, num_samples=None):\n \n return build_random_k_means(d, num_samples=num_samples)","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def cluster(n: int, model: str) -> NDArray[int]:\n return MiniBatchKMeans(n).fit_predict(XS[model])","def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\n for i in range(numClusters):\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\n return result","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\n self.d = d\n\n # 95% of data lies in a 2*sigma ball around the mean.\n # For unit variance normal, the 2*sigma ball mean the centers\n # should be at distance of 4 in the d dimensional space.\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\n cov = np.eye(d)\n\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\n # print(dist_mean)\n # cov = np.eye(d)\n\n frac = int(1 / pos_fraction)\n\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\n\n self.X = np.vstack((cluster1, cluster2))\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\n\n # Make blobs\n # if True:\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)","def kmeansClustering(data, x_scaled, clust, random_s):\n np.random.seed(random_s)\n #Performs clustering with the right number of clusters\n kmeans = KMeans(n_clusters=clust, random_state=random_s, n_jobs=-1).fit(x_scaled)\n kmeans = pd.DataFrame(kmeans.labels_, index=data.index, columns=[\"Clusters\"])\n #Merge on our main dataframe for better vizualisation of the clusters\n data_clust = pd.merge(data, kmeans, left_index=True, right_index=True, how='left')\n return data_clust","def kmeans(X, k, iterations=1000):\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\n return None, None\n if not isinstance(k, int) or k <= 0:\n return None, None\n if not isinstance(iterations, int) or iterations <= 0:\n return None, None\n n, d = X.shape\n X_min = X.min(axis=0)\n X_max = X.max(axis=0)\n C = np.random.uniform(X_min, X_max, size=(k, d))\n\n for i in range(iterations):\n centroids = np.copy(C)\n centroids_extended = C[:, np.newaxis]\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\n clss = np.argmin(distances, axis=0)\n for c in range(k):\n if X[clss == c].size == 0:\n C[c] = np.random.uniform(X_min, X_max, size=(1, d))\n else:\n C[c] = X[clss == c].mean(axis=0)\n\n centroids_extended = C[:, np.newaxis]\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\n clss = np.argmin(distances, axis=0)\n\n if (centroids == C).all():\n break\n\n return C, clss","def K_Means(self, n_clusters: int=150):\n start_time = datetime.datetime.now()\n self.func_log(\"\\n\\tIn K-Measn()\")\n \n kmeans = KMeans(n_clusters = n_clusters)\n kmeans.fit(self.descriptor_list)\n self.visual_words = kmeans.cluster_centers_ \n \n end_time = datetime.datetime.now() \n self.func_log(\"\\n\\t\\tTime Cost: {}\\n\".format(end_time-start_time))","def cluster(dfi, samples, num_clusters=8, random_state=1):\n df = dfi.fillna(0)\n X = df[samples].values\n kmeans = KMeans(n_clusters=num_clusters,\n random_state=random_state).fit(X)\n cluster_number = kmeans.labels_\n df['kmeans_cluster_number'] = cluster_number\n return df","def randomgrid(self, n):\n lam = np.random.random((n, 3))\n return self.normalize(lam)","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n clusters = list(cluster_list)\n\n # position initial clusters at the location of clusters with largest populations\n clusters.sort(reverse = True,\n key = lambda cluster: cluster.total_population())\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\n\n# Initialize old cluster using large population counties\n# For number of iterations\n# Initialize the new clusters to be empty\n# For each county\n# Find the old cluster center that is closest\n# Add the county to the corresponding new cluster\n# Set old clusters equal to new clusters\n# Return the new clusters\n\n for dummy_i in range(num_iterations):\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\n for county in cluster_list:\n county_x = county.horiz_center()\n county_y = county.vert_center()\n l_idx = [float('inf'), -1]\n for cluster in old_clusters:\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\n old_clusters = new_clusters\n\n return new_clusters","def get_centroid(nclass, nbit, maxtries=10000, initdist=0.61, mindist=0.2, reducedist=0.01):\n centroid = torch.zeros(nclass, nbit)\n i = 0\n count = 0\n currdist = initdist\n while i < nclass:\n print(i, end='\\r')\n c = torch.randn(nbit).sign()\n nobreak = True\n for j in range(i):\n if get_hd(c, centroid[j]) < currdist:\n i -= 1\n nobreak = False\n break\n if nobreak:\n centroid[i] = c\n else:\n count += 1\n\n if count >= maxtries:\n count = 0\n currdist -= reducedist\n print('reduce', currdist, i)\n if currdist < mindist:\n raise ValueError('cannot find')\n\n i += 1\n centroid = centroid[torch.randperm(nclass)]\n return centroid","def test_n_clusters(n_clusters):\n\n rng = np.random.RandomState(0)\n X = rng.rand(10, 2)\n\n bisect_means = BisectingKMeans(n_clusters=n_clusters, random_state=0)\n bisect_means.fit(X)\n\n assert_array_equal(np.unique(bisect_means.labels_), np.arange(n_clusters))","def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\n\n # generate clusters of blobs\n generated_points_x, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_x,\n cluster_std=std,\n n_features=1,\n )\n\n generated_points_y, _ = make_blobs(\n n_samples=n_samples_array,\n center_box=center_y,\n cluster_std=std,\n n_features=1,\n )\n\n # remove decimals\n generated_points_x = generated_points_x.astype(\"int\")\n generated_points_y = generated_points_y.astype(\"int\")\n\n ind_delete = np.logical_or.reduce(\n (\n generated_points_x < 0,\n generated_points_y < 0,\n generated_points_x > xsize - 1,\n generated_points_y > ysize - 1,\n ),\n )\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\n\n return generated_points_x, generated_points_y","def get_kmeans_mu(self, x, n_centers, init_times=50, min_delta=1e-3):\n if len(x.shape) == 3:\n x = tf.squeeze(x, 1)\n x_min, x_max = tf.reduce_min(x), tf.reduce_max(x)\n x = (x - x_min) / (x_max - x_min)\n\n random_state = check_random_state(self.random_state)\n\n min_cost = np.inf\n\n for i in range(init_times):\n tmp_center = x.numpy()[random_state.choice(np.arange(x.shape[0]), size=n_centers, replace=False), ...]\n l2_dis = tf.norm(tf.tile(tf.expand_dims(x, 1), (1, n_centers, 1)) - tmp_center, ord=2, axis=2)\n l2_cls = tf.argmin(l2_dis, axis=1)\n\n cost = 0\n for c in range(n_centers):\n cost += tf.reduce_mean(tf.norm(x[l2_cls == c] - tmp_center[c], ord=2, axis=1))\n\n if cost < min_cost:\n min_cost = cost\n center = tmp_center\n\n delta = np.inf\n while delta > min_delta:\n l2_dis = tf.norm(tf.tile(tf.expand_dims(x, 1), (1, n_centers, 1)) - center, ord=2, axis=2)\n l2_cls = tf.argmin(l2_dis, axis=1)\n center_old = tf.convert_to_tensor(center, dtype=tf.double)\n\n for c in range(n_centers):\n center[c] = tf.reduce_mean(x[l2_cls == c], axis=0)\n\n delta = tf.reduce_max(tf.reduce_sum(tf.square(center_old - center), axis=1))\n\n return tf.expand_dims(center, 0) * (x_max - x_min) + x_min","def kMeansInitCentroids(X, K):\n\tcentroids = np.zeros((K, X.shape[1])) # K centroids\n\tindex = []\n\n\t# Randomly select K different centroids\n\twhile len(index) != K:\n\t\ttmp = np.random.random_integers(0, X.shape[0] - 1)\n\t\tif tmp not in index:\n\t\t\tindex.append(tmp)\n\n\tcentroids[:, :] = X[index, :]\n\n\treturn centroids","def centroid(clusters):\n centroids = list(map(\n lambda cluster: tuple(map(\n lambda x, cluster=cluster: x / len(cluster['vertices']),\n sum(map(\n numpy.array,\n cluster['vertices'])))),\n clusters))\n return centroids","def generate_circles(num, mean, std):\n circles = np.zeros((num,3))\n # generate circle locations using a uniform distribution:\n circles[:,1:] = np.random.uniform(mean, SIZE-mean, size=(num,2))\n # generate radii using a normal distribution:\n circles[:,0] = np.random.normal(mean, std, size=(num,))\n return circles","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def kmeans_cluster(X_train_input, n_clusters=100):\r\n from sklearn.cluster import MiniBatchKMeans\r\n image_descriptors = []\r\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\r\n image_descriptors = np.array(image_descriptors) \r\n \r\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\r\n random_state=34, batch_size=128).fit(image_descriptors)\r\n \r\n return kmeans_model","def _2x3_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(2)\n for j in range(3)]","def _select_centers(self, X):\n random_args = np.random.choice(len(X), self.hidden_shape)\n centers = X[random_args]\n return centers","def k_means(x_input, n_cluster=3, n_iter=100, n_tries=10):\n results = []\n for _ in range(n_tries):\n error_value = 0\n rand.seed(None)\n centers = sorted([rand.uniform(0.0, 100.0) for i in range(n_cluster)])\n min_dist_idx = [0] * len(x_input)\n i = 0\n while i < n_iter:\n failed = False\n dist_mat = l2_pairwise_distance(x_input, centers)\n error_value = calculate_error(dist_mat)\n min_dist_idx = [dist.index(min(dist)) for dist in dist_mat]\n centers = [0] * n_cluster\n count = [0] * n_cluster\n for j in range(len(x_input)):\n centers[min_dist_idx[j]] += x_input[j]\n count[min_dist_idx[j]] += 1\n\n for j in range(n_cluster):\n if count[j] == 0:\n centers = sorted(\n [rand.uniform(0.0, 100.0) for i in range(n_cluster)])\n failed = True\n break\n\n if failed:\n i = 0\n continue\n\n for j in range(n_cluster):\n centers[j] = centers[j] / count[j]\n i += 1\n\n results.append((centers, min_dist_idx, error_value))\n\n return min(results, key=lambda x: x[2])","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def kmeans(\n x: np.ndarray,\n n_clusters: Optional[int] = 1,\n max_iterations: Optional[int] = 100,\n tol: Optional[float] = 1e-4,\n) -> np.ndarray:\n\n n_samples, n_variables, n_dimensions = x.shape[0], x.shape[1], x.shape[2]\n\n centroids = np.zeros((n_clusters, n_variables, n_dimensions))\n labels = np.zeros(n_samples)\n\n for i in range(n_clusters):\n idx = r.generate_integer_random_number(0, n_samples)\n centroids[i] = x[idx]\n\n for _ in range(max_iterations):\n dists = np.squeeze(np.array([np.linalg.norm(x - c, axis=1) for c in centroids]))\n updated_labels = np.squeeze(np.array(np.argmin(dists, axis=0)))\n\n ratio = np.sum(labels != updated_labels) / n_samples\n if ratio <= tol:\n break\n\n labels = updated_labels\n\n for i in range(n_clusters):\n centroid_samples = x[labels == i]\n if centroid_samples.shape[0] > 0:\n centroids[i] = np.mean(centroid_samples, axis=0)\n\n return labels","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def generate_clusterarray(k_cluster, cluster_size):\n result = np.zeros(k_cluster + 1, dtype = np.int32)\n for i in range(1,len(result)):\n result[i] = cluster_size\n return result","def private_centers(\n data, norm, epsilon, delta\n):\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\n n, d = data.shape\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)","def kmeans_cluster(\n cn,\n min_k=2,\n max_k=100,\n ):\n\n X = cn.T.values\n ks = range(min_k, max_k + 1)\n\n logging.info(f'trying with max k={max_k}')\n\n kmeans = []\n bics = []\n for k in ks:\n logging.info(f'trying with k={k}')\n model = sklearn.cluster.KMeans(n_clusters=k, init=\"k-means++\").fit(X)\n bic = compute_bic(model, X)\n kmeans.append(model)\n bics.append(bic)\n\n opt_k = np.array(bics).argmax()\n logging.info(f'selected k={opt_k}')\n\n model = kmeans[opt_k]\n\n embedding = umap.UMAP(\n n_neighbors=15,\n min_dist=0.1,\n n_components=2,\n random_state=42,\n metric='euclidean',\n ).fit_transform(cn.fillna(0).values.T)\n\n clusters = pd.DataFrame({\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\n })\n\n return clusters","def createCluster(method, n_clust=3, min_samples=5):\n if method == 'SpectralClustering':\n clust = SpectralClustering(n_clusters=n_clust)\n clust.fit(PC)\n scat = plt.scatter(-100, -100, zorder=2)\n elif method == 'OPTICS':\n clust = OPTICS(min_samples=min_samples)\n clust.fit(PC)\n scat = plt.scatter(PC[clust.labels_ == -1, 0],\n PC[clust.labels_ == -1, 1], c='k')\n return clust, scat","def get_s0_random_xy(N):\n s0x= []\n s0y = []\n s0z = []\n for i in range(N):\n s0z.append(0)\n r = 2 * np.pi * random.random()\n s0x.append(cos(r))\n s0y.append(sin(r))\n norm = np.linalg.norm([s0x [-1],s0y [-1],s0z [-1] ])\n s0x [-1] = s0x[-1] / norm\n s0y [-1] = s0y[-1] / norm\n s0z [-1] = s0z[-1] / norm\n return np.concatenate((s0x,s0y,s0z),axis = 0)"],"string":"[\n \"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\\n points_per_cluster = n_points // n_clusters\\n np.random.seed(seed=seed)\\n centroids = []\\n for _ in range(n_features):\\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\\n\\n centroids = np.array(zip(*centroids))\\n\\n points = []\\n for centroid in centroids:\\n rands = centroid + np.random.random((points_per_cluster, n_features)) * std\\n points.append(rands)\\n\\n return np.array(points).reshape(-1, 2)\",\n \"def random_centers(k,):\\n #centr = np.random.random((k, pos.shape[1]))\\n return\",\n \"def init_cluster_centroids(x, number_of_clusters):\\n return x[np.random.choice(x.shape[0], number_of_clusters, replace=False), :]\",\n \"def randCent(data,k):\\n index = set()\\n while len(index) != k:\\n index.add(random.randint(0, data.shape[0]))\\n index = list(index)\\n centroids = data[index]\\n return centroids\",\n \"def generate_centers(self):\\n\\t\\tcenters = []\\n\\t\\tsize = self.config.image_size\\n\\t\\tfor i in range(self.config.num_obj):\\n\\t\\t\\tflag = True\\n\\t\\t\\twhile flag:\\n\\t\\t\\t\\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\tfor center in centers:\\n\\t\\t\\t\\t\\tif (abs(center[0] - c[0]) <= 0.1 * size) or (abs(center[1] - c[1]) <= 0.1 *size):\\n\\t\\t\\t\\t\\t\\tflag = False\\n\\t\\t\\tcenters.append(c)\\n\\t\\t\\t\\t\\n\\t\\treturn centers\",\n \"def initialize_centers(data, k):\\n x_data_min = min(p[0] for p in data)\\n x_data_max = max(p[0] for p in data)\\n y_data_min = min(p[1] for p in data)\\n y_data_max = max(p[1] for p in data)\\n\\n return generate_random_data(\\n k,\\n x_data_min,\\n x_data_max,\\n y_data_min,\\n y_data_max\\n )\",\n \"def random_init(self, train_data):\\n\\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\\n for c in range(self.n_clusters_):\\n for f in range(train_data.shape[1]):\\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\\n\\n return centroids\",\n \"def gen_random_clusters(num_clusters):\\n clusters = []\\n\\n for _ in xrange(num_clusters):\\n clusters.append(alg_cluster.Cluster(\\n set(),\\n random.randint(-1, 1),\\n random.randint(-1, 1),\\n 0,\\n 0\\n ))\\n return clusters\",\n \"def gen_k_centers(k, dim):\\n delta = abs(np.random.normal(0.0, 5.0))\\n eps = 0.001\\n centers = []\\n for i in range(k):\\n c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))\\n if len(centers):\\n c1 = centers[0]\\n x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1\\n direction = x / np.linalg.norm(x)\\n centers.append(c1 + 2.0 * i * delta * direction + eps)\\n else:\\n centers.append(c)\\n return centers, delta\",\n \"def get_random_centroids(data, k) :\\r\\n centroids = []\\r\\n columns = np.size(data, axis=1)\\r\\n ranges = []\\r\\n for i in range(columns) :\\r\\n ranges.append([np.min(data[:,i]), np.max(data[:,i])])\\r\\n \\r\\n for i in range(k) :\\r\\n centroid = []\\r\\n for span in ranges :\\r\\n centroid.append(np.random.uniform(span[0], span[1]))\\r\\n centroids.append(centroid)\\r\\n \\r\\n return np.matrix(centroids)\",\n \"def gen_random_clusters(num_clusters):\\n\\t\\tcluster_list = []\\n\\t\\tlower_bound = -1\\n\\t\\tupper_bound = 1\\n\\t\\trange_width = upper_bound - lower_bound\\n\\t\\tfor idx in range(num_clusters):\\n\\t\\t\\tx_val = random.random() * range_width + lower_bound\\n\\t\\t\\ty_val = random.random() * range_width + lower_bound\\n\\t\\t\\tcluster_list.append(Cluster(set([]), x_val, y_val, 0, 0))\\n\\t\\treturn cluster_list\",\n \"def generateClustersRandomly(k=2, scale=1, num_clusters=1, points_per_cluster=20):\\n rands = [[np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)] for i in range(num_clusters)]\\n point_list = []\\n for rand in rands:\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n counter = 0\\n while counter < points_per_cluster:\\n nearCluster = np.array([np.random.uniform(-scale, scale) * np.random.rand() for _ in range(k)])\\n nearClusterLastItem = math.sqrt(1 + np.dot(nearCluster, nearCluster))\\n new_point = np.append(nearCluster, nearClusterLastItem)\\n # radius of hyperbolic ball is 0.2\\n if hyperboloidDist(new_point, rand) < .2:\\n point_list.append(new_point)\\n counter += 1\\n\\n return np.array(point_list)\",\n \"def initialize_clusters(points, k):\\r\\n return points[np.random.randint(points.shape[0], size=k)]\",\n \"def clusterize(x, n):\\n if n == 1:\\n return np.zeros(x.shape[0])\\n elif n > 1:\\n kmeans = KMeans(n_clusters=n).fit(x)\\n return kmeans.predict(x)\\n else:\\n raise ValueError(\\\"set n_spheres > 0\\\")\",\n \"def generateClusterPoints(N, k=2, scale=1):\\n rands = [[np.random.uniform(0, scale) * np.random.rand() for _ in range(k)] for i in range(N)]\\n rands += [[np.random.uniform(-scale, 0) * np.random.rand() for _ in range(k)] for i in range(N)]\\n point_list = []\\n for rand in rands:\\n # lastItem = math.sqrt(sum([1 + item**2 for item in rand]))\\n lastItem = math.sqrt(1 + np.dot(rand, rand))\\n rand.append(lastItem)\\n point_list.append(rand)\\n return np.array(point_list)\",\n \"def generate_initial_centroids(k, data):\\n centroids = []\\n used_indexes = []\\n while len(centroids) < k:\\n random_index = random.randint(0, len(data) - 1)\\n if random_index not in used_indexes:\\n centroids.append(data[random_index])\\n used_indexes.append(random_index)\\n return centroids\",\n \"def gen_random_clusters(num_clusters):\\n cluster_list = []\\n\\n for county_id in range(num_clusters):\\n cluster_list.append(alg_cluster.Cluster(set([str(county_id)]), 10.0*random.random(), 10.0*random.random(), random.random(), random.random()))\\n return cluster_list\",\n \"def recalculate_centers(data, k, clusters):\\n centers = []\\n for k_i in range(k):\\n inds = [i for i, j in enumerate(clusters) if j == k_i]\\n n = np.take(data, inds, axis=0)\\n if len(inds) == 0:\\n i = np.random.randint(len(data))\\n centers.append((data[i,0], data[i,1]))\\n\\n elif len(inds) < 2: \\n centers.append((n[0][0], n[0][1]))\\n else:\\n result = np.sum(n, axis=1)/len(inds)\\n centers.append((result[0], result[0]))\\n return centers\",\n \"def getRandomCentroids(data_points, k):\\n return random.sample(data_points, k)\",\n \"def init_centroids(self, points , k):\\n centroids = points.copy()\\n numpy.random.shuffle(centroids)\\n return centroids[0:k,:]\",\n \"def creaCent(data,k):\\n\\n Cen = random.sample(data[:,:].tolist(),k=k)\\n return np.asarray(Cen)\",\n \"def setup_rand_gmm(n_components=3, n_features=10,\\n clust_mean_std=2.0,\\n cluster_std=1.0,\\n cov_how='diag',\\n weights_how='uniform',\\n random_state=None):\\n\\n rng = check_random_state(random_state)\\n\\n ##########################\\n # generate cluster means #\\n ##########################\\n\\n # cluster means are generated from a spherical gaussian\\n center_cov = np.eye(n_features) * clust_mean_std ** 2\\n means = rng.multivariate_normal(mean=np.zeros(n_features),\\n cov=center_cov,\\n size=n_components)\\n\\n ################################\\n # generate cluster covariances #\\n ################################\\n\\n if cov_how.lower() == 'diag':\\n # diagonal covariances\\n covariances = np.array([np.eye(n_features) * cluster_std ** 2\\n for _ in range(n_components)])\\n elif cov_how.lower() == 'wishart':\\n raise NotImplementedError # TODO-FEAT: implement this!\\n else:\\n raise ValueError(\\\"cov_how must be one of ['diag', 'wishart']\\\"\\n \\\"not {}\\\".format(cov_how))\\n\\n ############################\\n # generate cluster weights #\\n ############################\\n if weights_how.lower() == 'uniform':\\n weights = rng.dirichlet(np.ones(n_components))\\n elif weights_how.lower() == 'random':\\n weights = np.ones(n_components) / n_components\\n else:\\n raise ValueError(\\\"weights_how must be one of ['random', 'uniform']\\\"\\n \\\"not {}\\\".format(weights_how))\\n\\n return means, covariances, weights\",\n \"def initialize_dom(img: np.ndarray):\\n\\n channels = img.shape[2]\\n\\n for cluster in range(numclusters):\\n for channel in range(channels):\\n cmin = np.amin(img[:,:,channel]) # channel's min\\n cmax = np.amax(img[:,:,channel]) # channel's max\\n current_cluster_centers[cluster, 0, channel] = np.random.uniform(cmin, cmax)\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def simulated_cluster(n_stars=CLUSTER_DEFAULTS['stars'],\\n dimensions=CLUSTER_DEFAULTS['dimensions']):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n image = gaussian_filter(image, sigma=1)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def _5x5_grid_clusters():\\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def initialize(img):\\n w, h, _ = img.shape\\n for c in current_cluster_centers:\\n x = np.random.randint(w)\\n y = np.random.randint(h)\\n c[:] = img[x, y]\",\n \"def init_centroids(X,K):\\n c = random.sample(list(X),K)\\n return c\",\n \"def initialize_pos(img: np.ndarray):\\n\\n h, w = img.shape[0:2]\\n\\n for cluster in range(numclusters):\\n i = np.random.randint(h) # row index\\n j = np.random.randint(w) # col index\\n current_cluster_centers[cluster, 0, :] = img[i, j, :]\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def Test_GenerateClusters(numClusters, pts_minmax=(10, 100), x_mult=(1, 4), y_mult=(1, 3), x_off=(0, 50), y_off=(0, 50)):\\n\\n # Initialize some empty lists to receive cluster member positions\\n testClustersx = []\\n testClustersy = []\\n # Genereate random values given parameter ranges\\n n_points = np.random.randint(pts_minmax[0], pts_minmax[1], numClusters)\\n x_multipliers = np.random.randint(x_mult[0], x_mult[1], numClusters)\\n y_multipliers = np.random.randint(y_mult[0], y_mult[1], numClusters)\\n x_offsets = np.random.randint(x_off[0], x_off[1], numClusters)\\n y_offsets = np.random.randint(y_off[0], y_off[1], numClusters)\\n\\n # Generate random clusters given parameter values\\n for idx, npts in enumerate(n_points):\\n xpts = np.random.randn(npts) * x_multipliers[idx] + x_offsets[idx]\\n ypts = np.random.randn(npts) * y_multipliers[idx] + y_offsets[idx]\\n testClustersx.append(xpts)\\n testClustersy.append(ypts)\\n\\n # Convert to a single dataset in OpenCV format\\n testClusters = np.float32((np.concatenate(testClustersx), np.concatenate(testClustersy))).transpose()\\n\\n # Return cluster positions\\n return testClusters, testClustersx, testClustersy\",\n \"def _get_init_centers(n_clusters, samples):\\n # randomly choose one initial sequence as the first center\\n init_ids = [0]\\n init_sequence = samples[0][0] # sequence\\n all_distances = []\\n # the idea is to choose medoids far away from each other\\n for _ in range(1, len(samples)):\\n current_seq = samples[_][0]\\n all_distances.append((_, distance_measuring(init_sequence, current_seq)))\\n arranged = sorted(all_distances, key=get_key, reverse=True) # descending order\\n arranged_ids = [_[0] for _ in arranged]\\n init_ids += arranged_ids[:n_clusters - 1]\\n return init_ids\",\n \"def __get_initial_centroid(self, x_train, seed=None):\\n if self.init == \\\"random\\\":\\n # randomly select n_cluster point from the input dataset\\n if seed:\\n random.seed(seed)\\n return np.asarray(random.choices(x_train, k=self.n_cluster))\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def initialize_pp(img: np.ndarray):\\n\\n h, w, c = img.shape\\n pixels = img.copy().reshape(h*w, c)\\n\\n # Choose one center uniformly at random \\n # from among the data points\\n r = np.random.randint(h*w)\\n current_cluster_centers[0, 0, :] = pixels[r, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, r, axis=0)\\n\\n # For each data point x, compute D(x), \\n # the distance between x and the nearest center \\n # that has already been chosen.\\n for k in range(1, numclusters):\\n dist_sq = np.zeros(pixels.shape[0])\\n for i in range(pixels.shape[0]): # over data points\\n dist = []\\n for j in range(k): # over current clusters\\n # calculate distance to the cluster\\n diff = pixels[i, :] - current_cluster_centers[j, 0, :]\\n dist.append(np.inner(diff, diff))\\n \\n # choose the distance closest to the cluster\\n dist_sq.itemset(i, min(dist))\\n\\n probs = dist_sq / dist_sq.sum()\\n cumprobs = probs.cumsum()\\n r = np.random.uniform()\\n for i, prob in enumerate(cumprobs):\\n if r <= prob:\\n index = i\\n break\\n \\n # add a new cluster\\n current_cluster_centers[k, 0, :] = pixels[index, :]\\n\\n # remove that point from the data set\\n pixels = np.delete(pixels, index, axis=0)\\n\\n\\n print(\\\"Current clusters:\\\\n\\\", current_cluster_centers)\",\n \"def _initiate_random_centroids(all_features, vocab_size):\\n centroids = []\\n # 1) Genereate points for initial centroids\\n\\n min_feat = np.ones(all_features[0].size)*np.inf\\n max_feat = np.zeros(all_features[0].size)\\n\\n for a in all_features:\\n for p in range(len(a)):\\n if a[p] < min_feat[p]:\\n min_feat[p] = a[p]\\n else:\\n if a[p] > max_feat[p]:\\n max_feat[p] = a[p]\\n\\n\\n for _ in range(vocab_size):\\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\\n max_feat-min_feat) + min_feat\\n centroids.append(random_vector.flatten())\\n\\n return np.array(centroids)\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def random_cluster_matrix(shape):\\n N, k = shape\\n A = np.zeros((N, k))\\n for row in A: \\n row[randint(0, k - 1)] = 1\\n\\n return A\",\n \"def recenter(self, n):\\n clustering = self\\n for i in xrange(n):\\n clustering = Clustering(clustering.recenter_iterator(), threshold=clustering.threshold,\\n consensus_threshold=clustering.consensus_threshold)\\n return clustering\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def clusterGen(k, colors):\\n clusters = []\\n # generate the clusters randomly\\n # for i in range(k):\\n # r = random.randint(0, 255)\\n # g = random.randint(0, 255)\\n # b = random.randint(0, 255)\\n # clusters.append((r, g, b))\\n\\n # generate the clusters that exist in colors\\n l = len(colors)\\n for i in range(k):\\n r = random.randint(0, l)\\n cluster = colors[r][1]\\n clusters.append(cluster)\\n\\n return clusters\",\n \"def simulated_cluster(n_stars=10000, dimensions=(512, 512)):\\n\\n nx, ny = dimensions\\n\\n # Create empty image\\n image = np.zeros((ny, nx))\\n\\n # Generate random positions\\n r = np.random.random(n_stars) * nx\\n theta = np.random.uniform(0., 2. * np.pi, n_stars)\\n\\n # Generate random fluxes\\n fluxes = np.random.random(n_stars) ** 2\\n\\n # Compute position\\n x = nx / 2 + r * np.cos(theta)\\n y = ny / 2 + r * np.sin(theta)\\n\\n # Add stars to image\\n # ==> First for loop and if statement <==\\n for idx in range(n_stars):\\n if x[idx] >= 0 and x[idx] < nx and y[idx] >= 0 and y[idx] < ny:\\n image[y[idx], x[idx]] += fluxes[idx]\\n\\n # Convolve with a gaussian\\n kernel = Gaussian2DKernel(stddev=1)\\n image = convolve_fft(image, kernel)\\n\\n # Add noise\\n image += np.random.normal(1., 0.001, image.shape)\\n\\n return image\",\n \"def plot_clustered_data(points, c_means, covs, test_name, image_num, gaussians):\\n\\t#colors = cm.rainbow(np.linspace(0, 1, gaussians))\\n\\tcolors = ['b', 'g', 'm', 'y', 'c', 'k']\\n\\n\\tax = plt.gca()\\n\\t#for i in range(points.shape[1]):\\n\\t\\t#plt.plot(points[:, i][0], points[:, i][1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\tplt.plot(points[0], points[1], \\\".\\\", color=\\\"r\\\", zorder=0)\\n\\t\\n\\tfor i in range(gaussians):\\n\\t\\tplt.plot(c_means[i][0], c_means[i][1], \\\".\\\", color=colors[i], zorder=1)\\n\\n\\t\\twidth, height, theta = cov_ellipse(points, covs[i], nstd=2)\\n\\t\\tellipse = Ellipse(xy=(c_means[i][0], c_means[i][1]), width=width, \\\\\\n\\t\\t\\t\\theight=height, angle=theta, edgecolor=colors[i], fc='None', lw=2,\\n\\t\\t\\t\\t\\t\\tzorder=4)\\n\\n\\t\\tax.add_patch(ellipse)\\n\\t\\n\\tplt.savefig(\\\"./images/{0}/{1:08d}.png\\\".format(test_name, image_num))\\n\\tplt.close()\",\n \"def create_clusters(N, K):\\n clusters = []\\n centroids = create_points(N, K)\\n for idx, centroid in enumerate(centroids):\\n cluster = Cluster(centroid)\\n cluster.label = _cluster_name(idx)\\n clusters.append(cluster)\\n return clusters\",\n \"def create_clusters(self):\\n ex = 0\\n print 'Iter - Purity Gini Index'\\n while ex < self.MAX_ITERATION:\\n new_clusters = np.zeros(self.centroids.shape)\\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\\n for i in range(self.K):\\n indexes = np.argwhere(distances == i)\\n data = self.vectors[indexes.transpose()[0]]\\n if data.shape[0] > 1:\\n new_clusters[i] = (np.sum(data, axis=0) / data.shape[0])\\n else:\\n new_clusters[i] = np.sum(data, axis=0)\\n print ex, '----', self.cal_purity()\\n ex += 1\\n if np.allclose(self.centroids, new_clusters, atol=self.TOLERANCE):\\n break\\n self.centroids = new_clusters\",\n \"def create_continuous_data(n_samples, n_var=10, n_dependent=0, pos_ratio=0, noise_ratio=0, n_cluster=1, mean=None, cov=None, random_state=None):\\n\\n if random_state is not None: np.random.seed(random_state)\\n\\n n_samples = n_samples//n_cluster\\n X_cluster, y_cluster, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster = [], [], [], [], [], []\\n\\n for cluster_idx in range(n_cluster):\\n # Group indicator\\n #group = sp.binom.rvs(p=0.25, n=1, size=N\\n n_neg = int(n_samples*(1-pos_ratio))\\n n_pos = n_samples-n_neg\\n y_cluster.append(np.concatenate([np.zeros(n_neg), np.ones(n_pos)]))\\n\\n idx_dependent = n_var - n_dependent\\n\\n if mean is None:\\n basic_mean = 0 #np.random.uniform(size=no_var)\\n mean0 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n mean1 = np.random.normal(loc=basic_mean, scale=1, size=n_var)\\n else:\\n mean0 = mean[cluster_idx][0]\\n mean1 = mean[cluster_idx][1]\\n \\n\\n # # Noise are variables with same distribution in majority and minority class\\n # if noise_ratio != 0:\\n # n_noise = int(noise_ratio*n_var)\\n # noise_idx = n_var - n_noise\\n # X_noise = sp.multivariate_normal.rvs(mean=mean0[noise_idx:], cov=cov0[noise_idx:,noise_idx:],\\n # size=n_samples).reshape([n_samples,-1])\\n \\n cov0, cov1 = None, None\\n\\n X1 = []\\n X0 = []\\n # Independent variables\\n if n_var-n_dependent > 0:\\n X1.append(sp.norm.rvs(loc=mean1[:idx_dependent], scale=1, size=[n_pos, n_var-n_dependent]) )\\n X0.append(sp.norm.rvs(loc=mean0[:idx_dependent], scale=1, size=[n_neg, n_var-n_dependent]) )\\n\\n # Dependent variables\\n if n_dependent>0:\\n if cov is None:\\n cov0 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n cov1 = sp.invwishart.rvs(df=n_var*1, scale=np.eye(n_dependent)*1)\\n else:\\n cov0 = cov[cluster_idx][0]\\n cov1 = cov[cluster_idx][1]\\n\\n X1.append( sp.multivariate_normal.rvs(mean=mean1[idx_dependent:],\\n cov= cov1, size=n_pos)\\n )\\n X0.append( sp.multivariate_normal.rvs(mean=mean0[idx_dependent:],\\n cov= cov0, size=n_neg)\\n )\\n \\n X0 = np.hstack([*X0])\\n X1 = np.hstack([*X1])\\n X_cluster.append(np.vstack([X0, X1]))\\n #X = np.hstack([X, X_noise])\\n\\n mean0_cluster.append(mean0)\\n mean1_cluster.append(mean1)\\n cov0_cluster.append(cov0)\\n cov1_cluster.append(cov1)\\n\\n if n_cluster == 1:\\n X = X_cluster[0]\\n y = y_cluster[0]\\n else:\\n X = np.vstack(X_cluster)\\n y = np.hstack(y_cluster)\\n\\n #return {\\\"X\\\":X, \\\"y\\\":y,\\\"mean0\\\":mean0,\\\"mean1\\\":mean1, \\\"cov0\\\":cov0, \\\"cov1\\\":cov1}\\n return X, y, mean0_cluster, mean1_cluster, cov0_cluster, cov1_cluster\",\n \"def initialize(X, k):\\n\\n if not isinstance(X, np.ndarray) or X.ndim != 2:\\n return None\\n\\n # n: number of dada points\\n # d: dimension of each data point\\n n, d = X.shape\\n # print(X.shape)\\n # print(X)\\n\\n if not isinstance(k, int) or k <= 0 or k > n:\\n return None\\n\\n # Sample k centroids from a random.uniform distribution;\\n # output is an array of coordinates\\n C = np.random.uniform(low=np.min(X, axis=0),\\n high=np.max(X, axis=0),\\n size=(k, d))\\n return C\",\n \"def create_gaussian_data(self, mean, std, nPoints, nClusters, nDimension):\\n dataset = np.zeros((nClusters, nPoints, nDimension), dtype=float)\\n for i in range(nClusters):\\n cov = std[i] ** 2\\n dataset[i, :, :] = np.random.multivariate_normal(mean[i], cov, nPoints)\\n\\n return dataset\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\\n initial_seed = np.random.get_state()\\n np.random.seed(seed)\\n points = np.random.rand(n, d)\\n np.random.set_state(initial_seed)\\n return points\",\n \"def generate_k(data_set, k):\\n centers = []\\n dimensions = len(data_set[0])\\n min_max = defaultdict(int)\\n\\n for point in data_set:\\n for i in range(dimensions):\\n val = point[i]\\n min_key = 'min_{0}d'.format(i)\\n max_key = 'max_{0}d'.format(i)\\n if min_key not in min_max or val < min_max[min_key]:\\n min_max[min_key] = val\\n if max_key not in min_max or val > min_max[max_key]:\\n min_max[max_key] = val\\n\\n for _k in range(k):\\n rand_point = []\\n for i in range(dimensions):\\n min_val = min_max['min_{0}d'.format(i)]\\n max_val = min_max['max_{0}d'.format(i)]\\n \\n rand_point.append(uniform(min_val, max_val))\\n centers.append(rand_point)\\n return centers\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\",\n \"def generate_tensor(shape, cluster_count=3, cluster_radius=3, low=0, high=255, eps=10, dtype=np.int32):\\n\\n tensor = np.zeros(shape, dtype)\\n\\n clusters = []\\n for i in range(cluster_count + 1):\\n cluster = {}\\n\\n coordinates = []\\n for dim in shape:\\n coordinate = np.random.randint(0, high=dim)\\n coordinates.append(coordinate)\\n\\n cluster['coordinates'] = coordinates\\n coordinates = tuple(coordinates)\\n\\n mask = generate_mask(shape, coordinates, cluster_radius)\\n\\n point_value = np.random.randint(low=low, high=high, size=1)[0]\\n point_value = int(point_value)\\n\\n cluster['center_value'] = point_value\\n cluster['radius'] = cluster_radius\\n\\n random_values = np.random.randint(low=point_value-eps, high=point_value+eps+1, size=shape)\\n random_values_masked = np.ma.array(random_values, mask=np.logical_not(mask))\\n\\n idx = (mask > 0)\\n tensor[idx] = random_values_masked[idx]\\n clusters.append(cluster)\\n\\n return tensor, clusters\",\n \"def _10x10_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(10)\\n for j in range(10)]\",\n \"def generate_parameters(self, cluster_center, std_dev, num_tasks):\\n return np.random.normal(cluster_center, std_dev, num_tasks)\",\n \"def initialize_centroids(X, K):\\n idx = np.random.choice(X.shape[0], K, replace = False)\\n centroids = X[idx,:]\\n return centroids\",\n \"def create_dataset(n_clusters, n_dim, n_samples, mean=None, std=None, seed=None):\\n if seed is not None:\\n np.random.seed(seed)\\n\\n if mean is None:\\n means = [np.random.randint(-(i + 1), (i + 1),\\n n_dim).astype(np.float32) for i in range(n_clusters)]\\n if std is None:\\n stds = []\\n for _ in range(n_clusters):\\n a = np.diag(random.rand(n_dim))\\n stds.append(a)\\n\\n data_set = []\\n cluster_id = []\\n for i, mean, std in zip(range(n_clusters), means, stds):\\n data_set.append(np.random.multivariate_normal(mean, std, n_samples))\\n cluster_id.append(np.ones(n_samples) * i)\\n\\n data_set = np.concatenate(data_set)\\n cluster_id = np.concatenate(cluster_id)\\n sample_idx = np.random.choice(data_set.shape[0], n_samples, replace=False)\\n\\n # Return correct amount of samples\\n return data_set[sample_idx, :], cluster_id[sample_idx]\",\n \"def get_cluster_centers(args=None, autoencoder=None, cluster_number=2, dataloader_list=None,\\n file_path=None, save_name=None, device='cpu'):\\n\\n if file_path: # Load centers from file and return them on device\\n print(\\\"Loading pretrained KMeans centroids\\\")\\n centers = np.loadtxt(file_path)\\n cluster_centers = torch.tensor(\\n centers, dtype=torch.float, requires_grad=True).to(device)\\n else: # Train Kmeans and generate centers\\n # https://github.com/vlukiyanov/pt-dec/blob/11b30553858c1c146a5ee0b696c768ab5244f0ff/ptdec/model.py#L74-L92\\n print(\\\"Training KMeans for centroids\\\")\\n kmeans = KMeans(n_clusters=cluster_number,\\n n_init=args.cluster_n_init, random_state=args.seed, max_iter=args.cluster_max_step)\\n autoencoder.eval()\\n features = []\\n actual = []\\n\\n # merge dataloaders\\n concat_dataset = torch.utils.data.ConcatDataset([x.dataset for x in dataloader_list])\\n\\n dataloader = torch.utils.data.DataLoader(\\n dataset=concat_dataset,\\n batch_size=args.encoder_bs\\n )\\n\\n # form initial cluster centres\\n data_iterator = tqdm(dataloader,\\n leave=True,\\n unit=\\\"batch\\\",\\n disable=False,\\n )\\n print(\\\"Generating features for kmeans\\\")\\n\\n with torch.no_grad():\\n # Loop through data and generate features from the encoder. \\n for index, batch in enumerate(data_iterator):\\n if (isinstance(batch, tuple) or isinstance(batch, list)) and len(batch) == 2:\\n # if we have a prediction label, separate it to actual\\n batch, value = batch\\n actual.append(value)\\n # Assuming we use the encoder from module.py\\n if args.encoder_type == 'vae':\\n feature = autoencoder(batch.to(device))\\n elif args.encoder_type == 'resnet50':\\n feature = list()\\n z = autoencoder(batch.to(device)) # [:,:args.dfc_hidden_dim]\\n\\n feature.append(z)\\n\\n features.append(feature[0].detach().cpu())\\n print(\\\"Training samples:\\\", len(features))\\n\\n actual = torch.cat(actual).long() # Save labels as long in torch tensor.\\n samples = torch.cat(features)\\n print(f\\\"Data shape {samples.shape}\\\")\\n print(f\\\"Labels shape {actual.shape}\\\")\\n print(\\\"Training...\\\")\\n predicted = kmeans.fit_predict(samples.numpy(), actual) # predict centers from features.\\n _, accuracy = cluster_accuracy(predicted, actual.cpu().numpy()) # Compute accuracy of predictions\\n cluster_centers = kmeans.cluster_centers_ # define centers\\n\\n if save_name: # If param. save_name then save the centers.\\n filepath = args.log_dir + save_name + \\\".txt\\\"\\n if not os.path.exists(args.log_dir):\\n os.mkdir(args.log_dir)\\n print(\\\"Saving clusters to:\\\", filepath)\\n np.savetxt(filepath, cluster_centers)\\n if not (wandb.run is None): # check if wandb is running\\n wandb.run.summary[f\\\"{save_name}_accuracy\\\"] = accuracy\\n\\n cluster_centers = torch.tensor( # Convert centers to tensor and send to device.\\n cluster_centers, dtype=torch.float, requires_grad=True\\n ).to(device)\\n print(f\\\"Training KMeans completed, accuracy: {accuracy:.2f}\\\")\\n return cluster_centers\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n # position initial clusters at the location of clusters with largest populations\\n cluster_list_copy = sorted(cluster_list,\\n reverse = True,\\n key=lambda cluster: cluster.total_population())\\n cluster_list_copy = cluster_list_copy[: num_clusters]\\n cluster_cent = [(cluster.horiz_center(), cluster.vert_center()) for cluster in cluster_list_copy]\\n result = []\\n #clustering to k initial centers adjusting the centers after each iteration\\n for dummy_q in range(num_iterations):\\n #Initialize k empty sets C1,...,Ck\\n k_clusters = []\\n for dummy_k in range(num_clusters):\\n k_clusters.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n for idx_j in range(len(cluster_list)):\\n # defining the closest k center and add the cluster to it\\n dist_list = []\\n for idx_k in range(num_clusters):\\n center_x, center_y = cluster_cent[idx_k]\\n dist = cluster_list[idx_j].distance(\\n alg_cluster.Cluster(set(), center_x, center_y, 0, 0))\\n dist_list.append((dist, idx_k))\\n dummy_k, idx = min(dist_list)\\n k_clusters[idx].merge_clusters(cluster_list[idx_j])\\n result = k_clusters\\n #update the new center of k clusters\\n cluster_cent = [(k_clusters[idx_f].horiz_center(), k_clusters[idx_f].vert_center()) for idx_f in range(num_clusters)]\\n return result\",\n \"def cluster_centers(X, k, bounds):\\n\\n mu = random_plane_points(k, bounds)\\n kmeans = sklearn.cluster.KMeans(init=mu)\\n kmeans.fit(X)\\n\\n # Restart if a mean has no associated points\\n if len(set(kmeans.labels_)) < k:\\n return cluster_centers(X, k, bounds)\\n\\n return kmeans.cluster_centers_\",\n \"def _5x5_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(5)\\n for j in range(5)]\",\n \"def kMeans(d, k):\\n #First get the random centroids from the data\\n newCentroids = getRandomCentroids(d, k)\\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\\n\\n #Get the clusters from these random centroids\\n clusters = initiateCentroid(d, newCentroids, k)\\n oldCentroids = []\\n\\n counter = 0\\n #While the old centroids are not equal to the new ones\\n while oldCentroids != newCentroids:\\n #old is equal to new\\n oldCentroids = newCentroids\\n #Calculate the new centroids\\n k, newCentroids = calcCentroids(d, clusters)\\n #Calculate the new clusters\\n clusters = initiateCentroid(d, newCentroids, k)\\n #Count how many iterations\\n counter += 1\\n\\n return counter, clusters\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def centers(pos):\\n number_of_nodes = len(pos)\\n ε, δ = 0.03, 0.1\\n r = 1 / (ε**2) * (int(np.log2(number_of_nodes - 1)) + 1 + np.log(1/δ))\\n k = int(np.sqrt(r))\\n k = np.min((k, number_of_nodes))\\n \\n return k_means_pp(k, pos)\",\n \"def random_spherepos(n):\\n signs = np.sign(rand.uniform(-1,1,size=n))\\n thetas = Angle(np.arccos(rand.uniform(size=n)*signs),unit=u.rad) #random b/w 0 and 180\\n phis = Angle(rand.uniform(0,2*np.pi,size=n),unit=u.rad)\\n c = SkyCoord(phis,thetas,1,representation='physicsspherical')\\n return c\",\n \"def random_assignment_of_clusters(self, data):\\n return np.random.randint(low=0, high=self.n_clusters, size=len(data[:, 0]))\",\n \"def random_k_means(d, num_samples=None):\\n \\n return build_random_k_means(d, num_samples=num_samples)\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def cluster(n: int, model: str) -> NDArray[int]:\\n return MiniBatchKMeans(n).fit_predict(XS[model])\",\n \"def initializeClusters(numClusters: int, numPrototypes: int) -> ndarray:\\n result: ndarray = np.empty((numClusters, numPrototypes), dtype=int)\\n for i in range(numClusters):\\n result[i, :] = [j for j in range(i * numPrototypes, (i + 1) * numPrototypes)]\\n return result\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\\n self.n = n\\n self.d = d\\n\\n # 95% of data lies in a 2*sigma ball around the mean.\\n # For unit variance normal, the 2*sigma ball mean the centers\\n # should be at distance of 4 in the d dimensional space.\\n mean1, mean2 = np.array([0.] * d), np.array([seperation / np.sqrt(d)] * d)\\n cov = np.eye(d)\\n\\n # mean1, mean2 = np.random.random_sample((d,)), np.random.random_sample((d,)) + np.power(seperation , 1 / (2*d))\\n dist_mean = np.linalg.norm(mean1 - mean2, ord=2)\\n # print(dist_mean)\\n # cov = np.eye(d)\\n\\n frac = int(1 / pos_fraction)\\n\\n cluster1 = np.random.multivariate_normal(mean1, cov, size=n // frac)\\n cluster2 = np.random.multivariate_normal(mean2, cov, size=(n - n//frac))\\n\\n self.X = np.vstack((cluster1, cluster2))\\n self.Y = np.array([0]*(n // frac) + [1]*(n - n // frac))\\n\\n # Make blobs\\n # if True:\\n # self.X, self.Y = make_blobs(n_samples=self.n, n_features=self.d, centers=2)\",\n \"def kmeansClustering(data, x_scaled, clust, random_s):\\n np.random.seed(random_s)\\n #Performs clustering with the right number of clusters\\n kmeans = KMeans(n_clusters=clust, random_state=random_s, n_jobs=-1).fit(x_scaled)\\n kmeans = pd.DataFrame(kmeans.labels_, index=data.index, columns=[\\\"Clusters\\\"])\\n #Merge on our main dataframe for better vizualisation of the clusters\\n data_clust = pd.merge(data, kmeans, left_index=True, right_index=True, how='left')\\n return data_clust\",\n \"def kmeans(X, k, iterations=1000):\\n if not isinstance(X, np.ndarray) or len(X.shape) != 2:\\n return None, None\\n if not isinstance(k, int) or k <= 0:\\n return None, None\\n if not isinstance(iterations, int) or iterations <= 0:\\n return None, None\\n n, d = X.shape\\n X_min = X.min(axis=0)\\n X_max = X.max(axis=0)\\n C = np.random.uniform(X_min, X_max, size=(k, d))\\n\\n for i in range(iterations):\\n centroids = np.copy(C)\\n centroids_extended = C[:, np.newaxis]\\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\\n clss = np.argmin(distances, axis=0)\\n for c in range(k):\\n if X[clss == c].size == 0:\\n C[c] = np.random.uniform(X_min, X_max, size=(1, d))\\n else:\\n C[c] = X[clss == c].mean(axis=0)\\n\\n centroids_extended = C[:, np.newaxis]\\n distances = np.sqrt(((X - centroids_extended) ** 2).sum(axis=2))\\n clss = np.argmin(distances, axis=0)\\n\\n if (centroids == C).all():\\n break\\n\\n return C, clss\",\n \"def K_Means(self, n_clusters: int=150):\\n start_time = datetime.datetime.now()\\n self.func_log(\\\"\\\\n\\\\tIn K-Measn()\\\")\\n \\n kmeans = KMeans(n_clusters = n_clusters)\\n kmeans.fit(self.descriptor_list)\\n self.visual_words = kmeans.cluster_centers_ \\n \\n end_time = datetime.datetime.now() \\n self.func_log(\\\"\\\\n\\\\t\\\\tTime Cost: {}\\\\n\\\".format(end_time-start_time))\",\n \"def cluster(dfi, samples, num_clusters=8, random_state=1):\\n df = dfi.fillna(0)\\n X = df[samples].values\\n kmeans = KMeans(n_clusters=num_clusters,\\n random_state=random_state).fit(X)\\n cluster_number = kmeans.labels_\\n df['kmeans_cluster_number'] = cluster_number\\n return df\",\n \"def randomgrid(self, n):\\n lam = np.random.random((n, 3))\\n return self.normalize(lam)\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n clusters = list(cluster_list)\\n\\n # position initial clusters at the location of clusters with largest populations\\n clusters.sort(reverse = True,\\n key = lambda cluster: cluster.total_population())\\n old_clusters = [clusters[idx] for idx in range(num_clusters)]\\n\\n# Initialize old cluster using large population counties\\n# For number of iterations\\n# Initialize the new clusters to be empty\\n# For each county\\n# Find the old cluster center that is closest\\n# Add the county to the corresponding new cluster\\n# Set old clusters equal to new clusters\\n# Return the new clusters\\n\\n for dummy_i in range(num_iterations):\\n new_clusters = [alg_cluster.Cluster(set(), 0, 0, 0, 0) for dummy_k in range(num_clusters)]\\n for county in cluster_list:\\n county_x = county.horiz_center()\\n county_y = county.vert_center()\\n l_idx = [float('inf'), -1]\\n for cluster in old_clusters:\\n distance = math.sqrt((county_x - cluster.horiz_center()) ** 2 + (county_y - cluster.vert_center()) ** 2)\\n l_idx = min(l_idx, [distance, old_clusters.index(cluster)])\\n new_clusters[l_idx[1]] = new_clusters[l_idx[1]].merge_clusters(county)\\n old_clusters = new_clusters\\n\\n return new_clusters\",\n \"def get_centroid(nclass, nbit, maxtries=10000, initdist=0.61, mindist=0.2, reducedist=0.01):\\n centroid = torch.zeros(nclass, nbit)\\n i = 0\\n count = 0\\n currdist = initdist\\n while i < nclass:\\n print(i, end='\\\\r')\\n c = torch.randn(nbit).sign()\\n nobreak = True\\n for j in range(i):\\n if get_hd(c, centroid[j]) < currdist:\\n i -= 1\\n nobreak = False\\n break\\n if nobreak:\\n centroid[i] = c\\n else:\\n count += 1\\n\\n if count >= maxtries:\\n count = 0\\n currdist -= reducedist\\n print('reduce', currdist, i)\\n if currdist < mindist:\\n raise ValueError('cannot find')\\n\\n i += 1\\n centroid = centroid[torch.randperm(nclass)]\\n return centroid\",\n \"def test_n_clusters(n_clusters):\\n\\n rng = np.random.RandomState(0)\\n X = rng.rand(10, 2)\\n\\n bisect_means = BisectingKMeans(n_clusters=n_clusters, random_state=0)\\n bisect_means.fit(X)\\n\\n assert_array_equal(np.unique(bisect_means.labels_), np.arange(n_clusters))\",\n \"def generate_points(self, n_samples_array, std, center_x, center_y, xsize, ysize):\\n\\n # generate clusters of blobs\\n generated_points_x, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_x,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n generated_points_y, _ = make_blobs(\\n n_samples=n_samples_array,\\n center_box=center_y,\\n cluster_std=std,\\n n_features=1,\\n )\\n\\n # remove decimals\\n generated_points_x = generated_points_x.astype(\\\"int\\\")\\n generated_points_y = generated_points_y.astype(\\\"int\\\")\\n\\n ind_delete = np.logical_or.reduce(\\n (\\n generated_points_x < 0,\\n generated_points_y < 0,\\n generated_points_x > xsize - 1,\\n generated_points_y > ysize - 1,\\n ),\\n )\\n generated_points_y = np.delete(generated_points_y, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n generated_points_x = np.delete(generated_points_x, ind_delete.reshape(ind_delete.shape[0]), axis=0)\\n\\n return generated_points_x, generated_points_y\",\n \"def get_kmeans_mu(self, x, n_centers, init_times=50, min_delta=1e-3):\\n if len(x.shape) == 3:\\n x = tf.squeeze(x, 1)\\n x_min, x_max = tf.reduce_min(x), tf.reduce_max(x)\\n x = (x - x_min) / (x_max - x_min)\\n\\n random_state = check_random_state(self.random_state)\\n\\n min_cost = np.inf\\n\\n for i in range(init_times):\\n tmp_center = x.numpy()[random_state.choice(np.arange(x.shape[0]), size=n_centers, replace=False), ...]\\n l2_dis = tf.norm(tf.tile(tf.expand_dims(x, 1), (1, n_centers, 1)) - tmp_center, ord=2, axis=2)\\n l2_cls = tf.argmin(l2_dis, axis=1)\\n\\n cost = 0\\n for c in range(n_centers):\\n cost += tf.reduce_mean(tf.norm(x[l2_cls == c] - tmp_center[c], ord=2, axis=1))\\n\\n if cost < min_cost:\\n min_cost = cost\\n center = tmp_center\\n\\n delta = np.inf\\n while delta > min_delta:\\n l2_dis = tf.norm(tf.tile(tf.expand_dims(x, 1), (1, n_centers, 1)) - center, ord=2, axis=2)\\n l2_cls = tf.argmin(l2_dis, axis=1)\\n center_old = tf.convert_to_tensor(center, dtype=tf.double)\\n\\n for c in range(n_centers):\\n center[c] = tf.reduce_mean(x[l2_cls == c], axis=0)\\n\\n delta = tf.reduce_max(tf.reduce_sum(tf.square(center_old - center), axis=1))\\n\\n return tf.expand_dims(center, 0) * (x_max - x_min) + x_min\",\n \"def kMeansInitCentroids(X, K):\\n\\tcentroids = np.zeros((K, X.shape[1])) # K centroids\\n\\tindex = []\\n\\n\\t# Randomly select K different centroids\\n\\twhile len(index) != K:\\n\\t\\ttmp = np.random.random_integers(0, X.shape[0] - 1)\\n\\t\\tif tmp not in index:\\n\\t\\t\\tindex.append(tmp)\\n\\n\\tcentroids[:, :] = X[index, :]\\n\\n\\treturn centroids\",\n \"def centroid(clusters):\\n centroids = list(map(\\n lambda cluster: tuple(map(\\n lambda x, cluster=cluster: x / len(cluster['vertices']),\\n sum(map(\\n numpy.array,\\n cluster['vertices'])))),\\n clusters))\\n return centroids\",\n \"def generate_circles(num, mean, std):\\n circles = np.zeros((num,3))\\n # generate circle locations using a uniform distribution:\\n circles[:,1:] = np.random.uniform(mean, SIZE-mean, size=(num,2))\\n # generate radii using a normal distribution:\\n circles[:,0] = np.random.normal(mean, std, size=(num,))\\n return circles\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def kmeans_cluster(X_train_input, n_clusters=100):\\r\\n from sklearn.cluster import MiniBatchKMeans\\r\\n image_descriptors = []\\r\\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\\r\\n image_descriptors = np.array(image_descriptors) \\r\\n \\r\\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\\r\\n random_state=34, batch_size=128).fit(image_descriptors)\\r\\n \\r\\n return kmeans_model\",\n \"def _2x3_grid_clusters_spread():\\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\\n [0.0, 1.0]]))\\n for i in range(2)\\n for j in range(3)]\",\n \"def _select_centers(self, X):\\n random_args = np.random.choice(len(X), self.hidden_shape)\\n centers = X[random_args]\\n return centers\",\n \"def k_means(x_input, n_cluster=3, n_iter=100, n_tries=10):\\n results = []\\n for _ in range(n_tries):\\n error_value = 0\\n rand.seed(None)\\n centers = sorted([rand.uniform(0.0, 100.0) for i in range(n_cluster)])\\n min_dist_idx = [0] * len(x_input)\\n i = 0\\n while i < n_iter:\\n failed = False\\n dist_mat = l2_pairwise_distance(x_input, centers)\\n error_value = calculate_error(dist_mat)\\n min_dist_idx = [dist.index(min(dist)) for dist in dist_mat]\\n centers = [0] * n_cluster\\n count = [0] * n_cluster\\n for j in range(len(x_input)):\\n centers[min_dist_idx[j]] += x_input[j]\\n count[min_dist_idx[j]] += 1\\n\\n for j in range(n_cluster):\\n if count[j] == 0:\\n centers = sorted(\\n [rand.uniform(0.0, 100.0) for i in range(n_cluster)])\\n failed = True\\n break\\n\\n if failed:\\n i = 0\\n continue\\n\\n for j in range(n_cluster):\\n centers[j] = centers[j] / count[j]\\n i += 1\\n\\n results.append((centers, min_dist_idx, error_value))\\n\\n return min(results, key=lambda x: x[2])\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def kmeans(\\n x: np.ndarray,\\n n_clusters: Optional[int] = 1,\\n max_iterations: Optional[int] = 100,\\n tol: Optional[float] = 1e-4,\\n) -> np.ndarray:\\n\\n n_samples, n_variables, n_dimensions = x.shape[0], x.shape[1], x.shape[2]\\n\\n centroids = np.zeros((n_clusters, n_variables, n_dimensions))\\n labels = np.zeros(n_samples)\\n\\n for i in range(n_clusters):\\n idx = r.generate_integer_random_number(0, n_samples)\\n centroids[i] = x[idx]\\n\\n for _ in range(max_iterations):\\n dists = np.squeeze(np.array([np.linalg.norm(x - c, axis=1) for c in centroids]))\\n updated_labels = np.squeeze(np.array(np.argmin(dists, axis=0)))\\n\\n ratio = np.sum(labels != updated_labels) / n_samples\\n if ratio <= tol:\\n break\\n\\n labels = updated_labels\\n\\n for i in range(n_clusters):\\n centroid_samples = x[labels == i]\\n if centroid_samples.shape[0] > 0:\\n centroids[i] = np.mean(centroid_samples, axis=0)\\n\\n return labels\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def generate_clusterarray(k_cluster, cluster_size):\\n result = np.zeros(k_cluster + 1, dtype = np.int32)\\n for i in range(1,len(result)):\\n result[i] = cluster_size\\n return result\",\n \"def private_centers(\\n data, norm, epsilon, delta\\n):\\n sigma = np.sqrt(2 * np.log(1.25 / delta)) / epsilon\\n n, d = data.shape\\n return np.mean(data, 0) + norm / n * np.random.normal(0, sigma, d)\",\n \"def kmeans_cluster(\\n cn,\\n min_k=2,\\n max_k=100,\\n ):\\n\\n X = cn.T.values\\n ks = range(min_k, max_k + 1)\\n\\n logging.info(f'trying with max k={max_k}')\\n\\n kmeans = []\\n bics = []\\n for k in ks:\\n logging.info(f'trying with k={k}')\\n model = sklearn.cluster.KMeans(n_clusters=k, init=\\\"k-means++\\\").fit(X)\\n bic = compute_bic(model, X)\\n kmeans.append(model)\\n bics.append(bic)\\n\\n opt_k = np.array(bics).argmax()\\n logging.info(f'selected k={opt_k}')\\n\\n model = kmeans[opt_k]\\n\\n embedding = umap.UMAP(\\n n_neighbors=15,\\n min_dist=0.1,\\n n_components=2,\\n random_state=42,\\n metric='euclidean',\\n ).fit_transform(cn.fillna(0).values.T)\\n\\n clusters = pd.DataFrame({\\n 'cell_id': cn.columns, 'cluster_id': model.labels_,\\n 'umap1': embedding[:, 0], 'umap2': embedding[:, 1]\\n })\\n\\n return clusters\",\n \"def createCluster(method, n_clust=3, min_samples=5):\\n if method == 'SpectralClustering':\\n clust = SpectralClustering(n_clusters=n_clust)\\n clust.fit(PC)\\n scat = plt.scatter(-100, -100, zorder=2)\\n elif method == 'OPTICS':\\n clust = OPTICS(min_samples=min_samples)\\n clust.fit(PC)\\n scat = plt.scatter(PC[clust.labels_ == -1, 0],\\n PC[clust.labels_ == -1, 1], c='k')\\n return clust, scat\",\n \"def get_s0_random_xy(N):\\n s0x= []\\n s0y = []\\n s0z = []\\n for i in range(N):\\n s0z.append(0)\\n r = 2 * np.pi * random.random()\\n s0x.append(cos(r))\\n s0y.append(sin(r))\\n norm = np.linalg.norm([s0x [-1],s0y [-1],s0z [-1] ])\\n s0x [-1] = s0x[-1] / norm\\n s0y [-1] = s0y[-1] / norm\\n s0z [-1] = s0z[-1] / norm\\n return np.concatenate((s0x,s0y,s0z),axis = 0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76822317","0.76259226","0.73836875","0.7335838","0.7241687","0.7094557","0.7092686","0.7072594","0.7042424","0.6994134","0.6977371","0.69499964","0.6929814","0.6919069","0.6892269","0.6817309","0.6758312","0.6726237","0.6718225","0.66974187","0.6696951","0.6625178","0.662123","0.6589652","0.6539657","0.64829224","0.6467993","0.64054203","0.63689655","0.6366787","0.6366787","0.63338524","0.6307443","0.62894154","0.62877923","0.6274301","0.6252224","0.62516433","0.6248435","0.62481356","0.62361336","0.62359655","0.6229967","0.62266994","0.6225596","0.62209135","0.620775","0.6201525","0.6179809","0.6162821","0.6151264","0.6116459","0.60987586","0.60910076","0.60884094","0.60829943","0.6077083","0.6068111","0.60540944","0.60537857","0.6046426","0.60134965","0.6013488","0.6012069","0.60051054","0.60041815","0.6001852","0.5990977","0.5980615","0.597904","0.5938282","0.59358627","0.59346163","0.59313864","0.59178025","0.5907654","0.5906907","0.5902445","0.589142","0.5874916","0.5874495","0.5846876","0.584442","0.5837086","0.58362365","0.58258307","0.5820122","0.5817104","0.580874","0.580506","0.5796207","0.5792949","0.57854843","0.5781305","0.57781965","0.5771189","0.5767826","0.57676375","0.57644004","0.5763345"],"string":"[\n \"0.76822317\",\n \"0.76259226\",\n \"0.73836875\",\n \"0.7335838\",\n \"0.7241687\",\n \"0.7094557\",\n \"0.7092686\",\n \"0.7072594\",\n \"0.7042424\",\n \"0.6994134\",\n \"0.6977371\",\n \"0.69499964\",\n \"0.6929814\",\n \"0.6919069\",\n \"0.6892269\",\n \"0.6817309\",\n \"0.6758312\",\n \"0.6726237\",\n \"0.6718225\",\n \"0.66974187\",\n \"0.6696951\",\n \"0.6625178\",\n \"0.662123\",\n \"0.6589652\",\n \"0.6539657\",\n \"0.64829224\",\n \"0.6467993\",\n \"0.64054203\",\n \"0.63689655\",\n \"0.6366787\",\n \"0.6366787\",\n \"0.63338524\",\n \"0.6307443\",\n \"0.62894154\",\n \"0.62877923\",\n \"0.6274301\",\n \"0.6252224\",\n \"0.62516433\",\n \"0.6248435\",\n \"0.62481356\",\n \"0.62361336\",\n \"0.62359655\",\n \"0.6229967\",\n \"0.62266994\",\n \"0.6225596\",\n \"0.62209135\",\n \"0.620775\",\n \"0.6201525\",\n \"0.6179809\",\n \"0.6162821\",\n \"0.6151264\",\n \"0.6116459\",\n \"0.60987586\",\n \"0.60910076\",\n \"0.60884094\",\n \"0.60829943\",\n \"0.6077083\",\n \"0.6068111\",\n \"0.60540944\",\n \"0.60537857\",\n \"0.6046426\",\n \"0.60134965\",\n \"0.6013488\",\n \"0.6012069\",\n \"0.60051054\",\n \"0.60041815\",\n \"0.6001852\",\n \"0.5990977\",\n \"0.5980615\",\n \"0.597904\",\n \"0.5938282\",\n \"0.59358627\",\n \"0.59346163\",\n \"0.59313864\",\n \"0.59178025\",\n \"0.5907654\",\n \"0.5906907\",\n \"0.5902445\",\n \"0.589142\",\n \"0.5874916\",\n \"0.5874495\",\n \"0.5846876\",\n \"0.584442\",\n \"0.5837086\",\n \"0.58362365\",\n \"0.58258307\",\n \"0.5820122\",\n \"0.5817104\",\n \"0.580874\",\n \"0.580506\",\n \"0.5796207\",\n \"0.5792949\",\n \"0.57854843\",\n \"0.5781305\",\n \"0.57781965\",\n \"0.5771189\",\n \"0.5767826\",\n \"0.57676375\",\n \"0.57644004\",\n \"0.5763345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7926905"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":9494,"cells":{"query":{"kind":"string","value":"Method that returns the JSON string representation of list_dictionaries"},"document":{"kind":"string","value":"def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n return \"[]\"\n else:\n string = json.dumps(list_dictionaries)\n return string"},"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 to_json_string(list_dictionaries):\n if list_dictionaries is None:\n list_dictionaries = []\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n list_dictionaries = []\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n return(\"[]\")\n json_string = json.dumps(list_dictionaries)\n return(json_string)","def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if not list_dictionaries or list_dictionaries is None:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or len(list_dictionaries) < 1:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or len(list_dictionaries) is 0:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n\n if list_dictionaries is None or len(list_dictionaries) <= 0:\n return '[]'\n\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if not list_dictionaries:\n return \"[]\"\n if (type(list_dictionaries) != list or\n not all(type(x) == dict for x in list_dictionaries)):\n raise TypeError(\"list_dictionaries must be a list of dictionaries\")\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or list_dictionaries == []:\n return \"[]\"\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or len(list_dictionaries) == 0:\n return (\"[]\")\n else:\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n\n if list_dictionaries is None or list_dictionaries == []:\n return (\"[]\")\n\n else:\n return (json.dumps(list_dictionaries))","def to_json_string(list_dictionaries):\n\n if list_dictionaries is None or len(list_dictionaries) == 0:\n return \"[]\"\n else:\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or list_dictionaries == []:\n return \"[]\"\n else:\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n\n if list_dictionaries is None or list_dictionaries == []:\n return \"[]\"\n if (type(list_dictionaries) != list or\n not all(type(dicts) == dict for dicts in list_dictionaries)):\n raise TypeError(\"list_dictionaries must be a list of dictionaries\")\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries is None or not list_dictionaries:\n return \"[]\"\n else:\n return json.dumps(list_dictionaries)","def to_json_string(list_dictionaries):\n if list_dictionaries and list_dictionaries is not None:\n return json.dumps(list_dictionaries)\n else:\n return \"[]\"","def list_to_json(items):\n return json.dumps(to_dict_list(items))","def format_json(the_list):\n result = \"{\"\n index = 0\n size = len(the_list)\n while index < size:\n result += format_json_key(the_list[index][0], the_list[index][1])\n if index != size - 1:\n result += \", \"\n index += 1\n result += \"}\"\n return result","def json_keys(lst, dct):\n if lst:\n _str = '{'\n for str_key in lst:\n _str += ''.join(['\"', str_key, '\":\"', dct[str_key], '\",'])\n str_json = _str[:-1] + \"}\"\n else:\n str_json = \"{}\"\n return str_json","def to_json(self) -> str:\n data_dict = self._to_list_dict()\n return json.dumps(data_dict, indent=4, cls=NumpyEncoder)","def to_dict(self) -> dict:\n\n value_list = []\n if self.list_values:\n for value in self.list_values:\n if isinstance(value, dict):\n value_list.append(value)\n elif isinstance(value, PicklistValue):\n value_list.append(value.to_dict())\n else:\n raise TypeError(f\"Invalid type for `list_values` in Picklist.to_dict:\"\n f\"{type(self.list_values)}, {self.list_values}\")\n\n output = {\n \"list_name\": self.list_name.__str__(),\n \"list_values\": value_list,\n \"last_modified\": self.last_modified.timestamp() * 1000 # JS timestamps are in ms\n }\n\n return output","def __transform_list_to_jsons__(self, listofjsons):\n jsons = []\n for row in listofjsons:\n jsons += [json.dumps(row)]\n return jsons","def to_json(self):\n return _convert_list_to_json(self.properties)","def to_json(self):\n return serialize_list_by_id(self.id)","def json(self):\n json_data = {}\n\n for item in self.iteritems():\n try:\n value = item.get_value(json_serializable=True)\n except TypeError:\n value = \"NOT_SERIALIZABLE\"\n item_data = {\n \"tags\": list(item.tags),\n \"value\": value,\n }\n if item.name in json_data:\n json_data[item.name].append(item_data)\n else:\n json_data[item.name] = [item_data]\n\n return json_data","def view_values(self, attr_list): # DONE\n values = {}\n for attr in attr_list:\n values[attr] = list(self.data[attr].values)\n return json.dumps(values)","def json(self):\n return [t.json for t in self.values()]","def json_taglist():\n tags = Tag.query.all()\n out = {'tags': []}\n for tag in tags:\n out['tags'].append(tag.value)\n\n return jsonify(out)","def row_list_to_json(rows: List[sqlite3.Row]) -> str:\n l = []\n for row in rows:\n l.append(row_to_json(row))\n\n return json.dumps(l)","def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:","def to_json_string(self):\n\t\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \"\\n\"","def json(self) -> List[Dict[str, Union[str, List[str]]]]:\n model_json: List[Dict[str, Union[str, List[str]]]] = []\n for phrase in self.phrase_index:\n entry = {'phrase': phrase}\n if phrase in self.has_variants:\n entry['variants'] = list(self.has_variants[phrase])\n if phrase in self.has_labels:\n entry['label'] = list(self.has_labels[phrase])\n if phrase in self.custom:\n entry['custom'] = self.custom[phrase]\n model_json += [entry]\n return model_json","def to_dict(self) -> List[Dict[str, Any]]:\n return [x.to_dict() for x in self.params]","def ToJson(self):\n output = json.dumps(self.ToDictionary(), sort_keys=True, indent=4)\n return output","def devicelist_to_json(self):\n devices_json = json.dumps(self.device_list)\n print(devices_json)","def toJson(self):\n text = '{'\n if len(self._sequence):\n for key in self._sequence:\n text += '\"%s\":%s,' % (key,json.dumps(self.dictionary[key]))\n text = text[:-1]\n text += '}'\n\n return text","def json(self):\n return json.dumps(self, default=lambda o: o.__dict__,\n sort_keys=True, indent=4)","def to_json(self) -> str:\n return json.dumps([x.to_dict() for x in self.inputs])","def list_to_json(list):\n print(inspect.stack()[1][3])\n op = {}\n for (a, b) in zip((Followup.c.keys()), list):\n op[a] = str(b).replace('followup.', '')\n return op","def list_to_json(input_list, file_name):\n with open(file_name, 'w') as outfile:\n json.dump(input_list, outfile)","def dict(self):\n\t\treturn self.json","def AsJsonString(self):\n return json.dumps(self.AsDict(), sort_keys=True)","def serialize_list(list_raw):\n list_serialized = []\n for value in list_raw:\n if isinstance(value, list):\n list_serialized.append(serialize_list(value))\n elif isinstance(value, dict):\n list_serialized.append(serialize_dict(value))\n else:\n list_serialized.append(unidecode.unidecode(str(value)))\n return list_serialized","def serialize_list(list_raw):\n list_serialized = []\n for value in list_raw:\n if isinstance(value, list):\n list_serialized.append(serialize_list(value))\n elif isinstance(value, dict):\n list_serialized.append(serialize_dict(value))\n else:\n list_serialized.append(unidecode.unidecode(str(value)))\n return list_serialized","def format(self):\r\n output = {}\r\n\r\n for k, v in self:\r\n if type(v) == collections.InstrumentedList: # pragma: no cover\r\n output[k] = [item.to_dict() for item in v]\r\n elif isinstance(v, (date, datetime, time)): # pragma: no cover\r\n output[k] = v.isoformat()\r\n elif isinstance(v, (float, Decimal)): # pragma: no cover\r\n output[k] = str(v)\r\n else:\r\n output[k] = v\r\n\r\n return output","def json(self):\n return {\n \"instance_id\" : self.instance_id,\n \"library_id\" : self.library_id,\n \"symbol_index\" : self.symbol_index,\n \"symbol_attributes\":[s.json() for s in self.symbol_attributes],\n \"attributes\" : stringify_attributes(self.attributes)\n }","def list():\n trucks = Foodtruck.query.all()\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])","def list_items(self) -> List[Dict[str, Any]]:\n return [c.to_dict() for c in self._objects.values()]","def json(self):\n robot_dict = self.robot_dict()\n target_dict = self.target_dict()\n json_str = '{'\n json_str = json_str + '\"robot_obj\" : ' + json.dumps(robot_dict) + \",\\n\"\n json_str = json_str + '\"target_obj\" : ' + json.dumps(target_dict) + \"\\n\"\n json_str = json_str + '}'\n return(json_str)","def to_json(peaklist):\n pl = [{\"Assignment\": peak.assignments_list,\n \"Dimensions\": peak.chem_shifts_list,\n \"DataHeight\": peak.extra_attr} for peak in peaklist]\n json_str = json.dumps(pl)\n return json_str","def GetJSON(self):\n return json.dumps(self.GetDict())","def jsonify_list(data):\n assert data is not None\n indent = None\n if (current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] and\n not request.is_xhr):\n indent = 2\n data = dumps(data, indent=indent, sort_keys=False)\n\n mimetype = 'application/json; charset=utf-8'\n response = current_app.response_class(data, mimetype=mimetype)\n\n return response","def as_json_string(self):\n return json.dumps(self.as_dict(), sort_keys=True)","def serialize(self):\n return {\n 'list_id': self.list_id,\n 'name': self.name,\n 'date_time': dump_datetime(self.date)\n }","def asJsonString(self):\n return json.dumps(self.asDict(), sort_keys=True)","def to_json_string(self):\n return json.dumps(dict(self), indent=2, sort_keys=True) + \"\\n\"","def convert_to_json(data):\n return json.dumps({'items': [item._asdict() for item in data]}, ensure_ascii=False, indent=2)","def to_listing_dict(self) -> dict:\n data = super().to_listing_dict()\n return data","def to_json(self):\n return json.dumps(self.dict)","def to_json_string(self) -> None:\n return json.dumps(dataclasses.asdict(self)) + \"\\n\"","def pprint(self):\n import json\n return json.dumps(OrderedDict(self.items()), indent=4)","def as_json(self):\n return json.dumps(self.as_dict(), indent=2, sort_keys=False)","def to_dict_list(items):\n dictionaries = []\n for item in items:\n if not isinstance(item, JsonSerializable):\n raise ValueError('Items must of type JsonSerializable')\n dictionaries.append(item.__dict__)\n return dictionaries","def to_json(self) -> str:\n return json.dumps(asdict(self))","def to_json_string(self):\n\t\treturn json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def serialise(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'items': [i.serialise for i in self.items]\n }","def _convert_list_to_json(array):\n return json.dumps(array, skipkeys=False, allow_nan=False, indent=None, separators=(\",\", \":\"))","def to_json(self):\n return json.dumps({\"data\": self._data.tolist(),\n \"header\": self._header.tolist(),\n \"dates\": self._dates.tolist()})","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def to_json_string(self):\n return json.dumps(self.to_dict(), indent = 2, sort_keys = True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json_string(self):\r\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def json(self):\n\n json = {}\n json['type'] = self.type\n json['value'] = self.value\n json['status'] = self.status\n json['tags'] = list(set(self.tags))\n json['relationships'] = list(set(self.relationships))\n json['whitelisted'] = self.whitelisted\n json['path'] = self.path\n\n return json","def to_json(self):\n quantille_data = dict(((key, quantille.dumps()) for key, quantille in self.__data.items()))\n return json.dumps((quantille_data, self.__keys, self.__value_keynames))","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\n indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\n indent=4)","def get_dict_repr(self):\n return { 'id': self.invoice_id,\n self.json_id: self.items }","def as_json(self):\n return json.dumps(self.as_dict())","def as_json(self):\n return json.dumps(self.as_dict())","def as_json(self):\n return json.dumps(self.as_dict())","def catalog_json():\n catalog_json = []\n try:\n all_categories = session.query(Category).all()\n for category in all_categories:\n items_for_category = session.query(\n Item).filter_by(\n category_id=category.id).all()\n items = []\n for current_item in items_for_category:\n items.append(current_item.serialize)\n catalog_json.append({\n 'category_name': category.name,\n 'category_id': category.id,\n 'items': items\n })\n except Exception as e:\n error = {\n 'result': 'No catalog data: ' + str(e)\n }\n catalog_json.append(error)\n return jsonify(catalog_json)","def to_json_string(self):\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"","def to_json(self, attrs=None):\n if type(attrs) is list:\n my_dict = {}\n for i in attrs:\n if i in self.__dict__:\n my_dict[i] = self.__dict__[i]\n return(my_dict)\n return(self.__dict__)","def to_json_str(self):\n return simplejson.dumps(self.to_json(), sort_keys=True)","def serialize(self):\n\n if util.config['redfish']['indent_json']:\n indent = 4\n else:\n indent = None\n return json.dumps(\n self.redfish,\n default=lambda o: o.__dict__,\n sort_keys=False,\n indent=indent)","def json_friendly(self):","def _jsonify_dict_values(params):\n\treturn { k: json.dumps(v)\tif isinstance(v, dict) or isinstance(v, list) else v\n\t\tfor k, v in params.items()\n\t}","def as_dict(self):\n d = self.__dict__\n # convert to list to be json safe\n d['words'] = {value: list(words) for value, words in self.words.items()}\n d['model'] = dict(self.model.get_params())\n return d"],"string":"[\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n list_dictionaries = []\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n list_dictionaries = []\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n return(\\\"[]\\\")\\n json_string = json.dumps(list_dictionaries)\\n return(json_string)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if not list_dictionaries or list_dictionaries is None:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or len(list_dictionaries) < 1:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or len(list_dictionaries) is 0:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n\\n if list_dictionaries is None or len(list_dictionaries) <= 0:\\n return '[]'\\n\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if not list_dictionaries:\\n return \\\"[]\\\"\\n if (type(list_dictionaries) != list or\\n not all(type(x) == dict for x in list_dictionaries)):\\n raise TypeError(\\\"list_dictionaries must be a list of dictionaries\\\")\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or list_dictionaries == []:\\n return \\\"[]\\\"\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or len(list_dictionaries) == 0:\\n return (\\\"[]\\\")\\n else:\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n\\n if list_dictionaries is None or list_dictionaries == []:\\n return (\\\"[]\\\")\\n\\n else:\\n return (json.dumps(list_dictionaries))\",\n \"def to_json_string(list_dictionaries):\\n\\n if list_dictionaries is None or len(list_dictionaries) == 0:\\n return \\\"[]\\\"\\n else:\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or list_dictionaries == []:\\n return \\\"[]\\\"\\n else:\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n\\n if list_dictionaries is None or list_dictionaries == []:\\n return \\\"[]\\\"\\n if (type(list_dictionaries) != list or\\n not all(type(dicts) == dict for dicts in list_dictionaries)):\\n raise TypeError(\\\"list_dictionaries must be a list of dictionaries\\\")\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None or not list_dictionaries:\\n return \\\"[]\\\"\\n else:\\n return json.dumps(list_dictionaries)\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries and list_dictionaries is not None:\\n return json.dumps(list_dictionaries)\\n else:\\n return \\\"[]\\\"\",\n \"def list_to_json(items):\\n return json.dumps(to_dict_list(items))\",\n \"def format_json(the_list):\\n result = \\\"{\\\"\\n index = 0\\n size = len(the_list)\\n while index < size:\\n result += format_json_key(the_list[index][0], the_list[index][1])\\n if index != size - 1:\\n result += \\\", \\\"\\n index += 1\\n result += \\\"}\\\"\\n return result\",\n \"def json_keys(lst, dct):\\n if lst:\\n _str = '{'\\n for str_key in lst:\\n _str += ''.join(['\\\"', str_key, '\\\":\\\"', dct[str_key], '\\\",'])\\n str_json = _str[:-1] + \\\"}\\\"\\n else:\\n str_json = \\\"{}\\\"\\n return str_json\",\n \"def to_json(self) -> str:\\n data_dict = self._to_list_dict()\\n return json.dumps(data_dict, indent=4, cls=NumpyEncoder)\",\n \"def to_dict(self) -> dict:\\n\\n value_list = []\\n if self.list_values:\\n for value in self.list_values:\\n if isinstance(value, dict):\\n value_list.append(value)\\n elif isinstance(value, PicklistValue):\\n value_list.append(value.to_dict())\\n else:\\n raise TypeError(f\\\"Invalid type for `list_values` in Picklist.to_dict:\\\"\\n f\\\"{type(self.list_values)}, {self.list_values}\\\")\\n\\n output = {\\n \\\"list_name\\\": self.list_name.__str__(),\\n \\\"list_values\\\": value_list,\\n \\\"last_modified\\\": self.last_modified.timestamp() * 1000 # JS timestamps are in ms\\n }\\n\\n return output\",\n \"def __transform_list_to_jsons__(self, listofjsons):\\n jsons = []\\n for row in listofjsons:\\n jsons += [json.dumps(row)]\\n return jsons\",\n \"def to_json(self):\\n return _convert_list_to_json(self.properties)\",\n \"def to_json(self):\\n return serialize_list_by_id(self.id)\",\n \"def json(self):\\n json_data = {}\\n\\n for item in self.iteritems():\\n try:\\n value = item.get_value(json_serializable=True)\\n except TypeError:\\n value = \\\"NOT_SERIALIZABLE\\\"\\n item_data = {\\n \\\"tags\\\": list(item.tags),\\n \\\"value\\\": value,\\n }\\n if item.name in json_data:\\n json_data[item.name].append(item_data)\\n else:\\n json_data[item.name] = [item_data]\\n\\n return json_data\",\n \"def view_values(self, attr_list): # DONE\\n values = {}\\n for attr in attr_list:\\n values[attr] = list(self.data[attr].values)\\n return json.dumps(values)\",\n \"def json(self):\\n return [t.json for t in self.values()]\",\n \"def json_taglist():\\n tags = Tag.query.all()\\n out = {'tags': []}\\n for tag in tags:\\n out['tags'].append(tag.value)\\n\\n return jsonify(out)\",\n \"def row_list_to_json(rows: List[sqlite3.Row]) -> str:\\n l = []\\n for row in rows:\\n l.append(row_to_json(row))\\n\\n return json.dumps(l)\",\n \"def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:\",\n \"def to_json_string(self):\\n\\t\\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def json(self) -> List[Dict[str, Union[str, List[str]]]]:\\n model_json: List[Dict[str, Union[str, List[str]]]] = []\\n for phrase in self.phrase_index:\\n entry = {'phrase': phrase}\\n if phrase in self.has_variants:\\n entry['variants'] = list(self.has_variants[phrase])\\n if phrase in self.has_labels:\\n entry['label'] = list(self.has_labels[phrase])\\n if phrase in self.custom:\\n entry['custom'] = self.custom[phrase]\\n model_json += [entry]\\n return model_json\",\n \"def to_dict(self) -> List[Dict[str, Any]]:\\n return [x.to_dict() for x in self.params]\",\n \"def ToJson(self):\\n output = json.dumps(self.ToDictionary(), sort_keys=True, indent=4)\\n return output\",\n \"def devicelist_to_json(self):\\n devices_json = json.dumps(self.device_list)\\n print(devices_json)\",\n \"def toJson(self):\\n text = '{'\\n if len(self._sequence):\\n for key in self._sequence:\\n text += '\\\"%s\\\":%s,' % (key,json.dumps(self.dictionary[key]))\\n text = text[:-1]\\n text += '}'\\n\\n return text\",\n \"def json(self):\\n return json.dumps(self, default=lambda o: o.__dict__,\\n sort_keys=True, indent=4)\",\n \"def to_json(self) -> str:\\n return json.dumps([x.to_dict() for x in self.inputs])\",\n \"def list_to_json(list):\\n print(inspect.stack()[1][3])\\n op = {}\\n for (a, b) in zip((Followup.c.keys()), list):\\n op[a] = str(b).replace('followup.', '')\\n return op\",\n \"def list_to_json(input_list, file_name):\\n with open(file_name, 'w') as outfile:\\n json.dump(input_list, outfile)\",\n \"def dict(self):\\n\\t\\treturn self.json\",\n \"def AsJsonString(self):\\n return json.dumps(self.AsDict(), sort_keys=True)\",\n \"def serialize_list(list_raw):\\n list_serialized = []\\n for value in list_raw:\\n if isinstance(value, list):\\n list_serialized.append(serialize_list(value))\\n elif isinstance(value, dict):\\n list_serialized.append(serialize_dict(value))\\n else:\\n list_serialized.append(unidecode.unidecode(str(value)))\\n return list_serialized\",\n \"def serialize_list(list_raw):\\n list_serialized = []\\n for value in list_raw:\\n if isinstance(value, list):\\n list_serialized.append(serialize_list(value))\\n elif isinstance(value, dict):\\n list_serialized.append(serialize_dict(value))\\n else:\\n list_serialized.append(unidecode.unidecode(str(value)))\\n return list_serialized\",\n \"def format(self):\\r\\n output = {}\\r\\n\\r\\n for k, v in self:\\r\\n if type(v) == collections.InstrumentedList: # pragma: no cover\\r\\n output[k] = [item.to_dict() for item in v]\\r\\n elif isinstance(v, (date, datetime, time)): # pragma: no cover\\r\\n output[k] = v.isoformat()\\r\\n elif isinstance(v, (float, Decimal)): # pragma: no cover\\r\\n output[k] = str(v)\\r\\n else:\\r\\n output[k] = v\\r\\n\\r\\n return output\",\n \"def json(self):\\n return {\\n \\\"instance_id\\\" : self.instance_id,\\n \\\"library_id\\\" : self.library_id,\\n \\\"symbol_index\\\" : self.symbol_index,\\n \\\"symbol_attributes\\\":[s.json() for s in self.symbol_attributes],\\n \\\"attributes\\\" : stringify_attributes(self.attributes)\\n }\",\n \"def list():\\n trucks = Foodtruck.query.all()\\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])\",\n \"def list_items(self) -> List[Dict[str, Any]]:\\n return [c.to_dict() for c in self._objects.values()]\",\n \"def json(self):\\n robot_dict = self.robot_dict()\\n target_dict = self.target_dict()\\n json_str = '{'\\n json_str = json_str + '\\\"robot_obj\\\" : ' + json.dumps(robot_dict) + \\\",\\\\n\\\"\\n json_str = json_str + '\\\"target_obj\\\" : ' + json.dumps(target_dict) + \\\"\\\\n\\\"\\n json_str = json_str + '}'\\n return(json_str)\",\n \"def to_json(peaklist):\\n pl = [{\\\"Assignment\\\": peak.assignments_list,\\n \\\"Dimensions\\\": peak.chem_shifts_list,\\n \\\"DataHeight\\\": peak.extra_attr} for peak in peaklist]\\n json_str = json.dumps(pl)\\n return json_str\",\n \"def GetJSON(self):\\n return json.dumps(self.GetDict())\",\n \"def jsonify_list(data):\\n assert data is not None\\n indent = None\\n if (current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] and\\n not request.is_xhr):\\n indent = 2\\n data = dumps(data, indent=indent, sort_keys=False)\\n\\n mimetype = 'application/json; charset=utf-8'\\n response = current_app.response_class(data, mimetype=mimetype)\\n\\n return response\",\n \"def as_json_string(self):\\n return json.dumps(self.as_dict(), sort_keys=True)\",\n \"def serialize(self):\\n return {\\n 'list_id': self.list_id,\\n 'name': self.name,\\n 'date_time': dump_datetime(self.date)\\n }\",\n \"def asJsonString(self):\\n return json.dumps(self.asDict(), sort_keys=True)\",\n \"def to_json_string(self):\\n return json.dumps(dict(self), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def convert_to_json(data):\\n return json.dumps({'items': [item._asdict() for item in data]}, ensure_ascii=False, indent=2)\",\n \"def to_listing_dict(self) -> dict:\\n data = super().to_listing_dict()\\n return data\",\n \"def to_json(self):\\n return json.dumps(self.dict)\",\n \"def to_json_string(self) -> None:\\n return json.dumps(dataclasses.asdict(self)) + \\\"\\\\n\\\"\",\n \"def pprint(self):\\n import json\\n return json.dumps(OrderedDict(self.items()), indent=4)\",\n \"def as_json(self):\\n return json.dumps(self.as_dict(), indent=2, sort_keys=False)\",\n \"def to_dict_list(items):\\n dictionaries = []\\n for item in items:\\n if not isinstance(item, JsonSerializable):\\n raise ValueError('Items must of type JsonSerializable')\\n dictionaries.append(item.__dict__)\\n return dictionaries\",\n \"def to_json(self) -> str:\\n return json.dumps(asdict(self))\",\n \"def to_json_string(self):\\n\\t\\treturn json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def serialise(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'items': [i.serialise for i in self.items]\\n }\",\n \"def _convert_list_to_json(array):\\n return json.dumps(array, skipkeys=False, allow_nan=False, indent=None, separators=(\\\",\\\", \\\":\\\"))\",\n \"def to_json(self):\\n return json.dumps({\\\"data\\\": self._data.tolist(),\\n \\\"header\\\": self._header.tolist(),\\n \\\"dates\\\": self._dates.tolist()})\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def to_json_string(self):\\n return json.dumps(self.to_dict(), indent = 2, sort_keys = True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json_string(self):\\r\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def json(self):\\n\\n json = {}\\n json['type'] = self.type\\n json['value'] = self.value\\n json['status'] = self.status\\n json['tags'] = list(set(self.tags))\\n json['relationships'] = list(set(self.relationships))\\n json['whitelisted'] = self.whitelisted\\n json['path'] = self.path\\n\\n return json\",\n \"def to_json(self):\\n quantille_data = dict(((key, quantille.dumps()) for key, quantille in self.__data.items()))\\n return json.dumps((quantille_data, self.__keys, self.__value_keynames))\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\\n indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\\n indent=4)\",\n \"def get_dict_repr(self):\\n return { 'id': self.invoice_id,\\n self.json_id: self.items }\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def catalog_json():\\n catalog_json = []\\n try:\\n all_categories = session.query(Category).all()\\n for category in all_categories:\\n items_for_category = session.query(\\n Item).filter_by(\\n category_id=category.id).all()\\n items = []\\n for current_item in items_for_category:\\n items.append(current_item.serialize)\\n catalog_json.append({\\n 'category_name': category.name,\\n 'category_id': category.id,\\n 'items': items\\n })\\n except Exception as e:\\n error = {\\n 'result': 'No catalog data: ' + str(e)\\n }\\n catalog_json.append(error)\\n return jsonify(catalog_json)\",\n \"def to_json_string(self):\\n return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def to_json(self, attrs=None):\\n if type(attrs) is list:\\n my_dict = {}\\n for i in attrs:\\n if i in self.__dict__:\\n my_dict[i] = self.__dict__[i]\\n return(my_dict)\\n return(self.__dict__)\",\n \"def to_json_str(self):\\n return simplejson.dumps(self.to_json(), sort_keys=True)\",\n \"def serialize(self):\\n\\n if util.config['redfish']['indent_json']:\\n indent = 4\\n else:\\n indent = None\\n return json.dumps(\\n self.redfish,\\n default=lambda o: o.__dict__,\\n sort_keys=False,\\n indent=indent)\",\n \"def json_friendly(self):\",\n \"def _jsonify_dict_values(params):\\n\\treturn { k: json.dumps(v)\\tif isinstance(v, dict) or isinstance(v, list) else v\\n\\t\\tfor k, v in params.items()\\n\\t}\",\n \"def as_dict(self):\\n d = self.__dict__\\n # convert to list to be json safe\\n d['words'] = {value: list(words) for value, words in self.words.items()}\\n d['model'] = dict(self.model.get_params())\\n return d\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.841099","0.841099","0.8314405","0.8295821","0.8295821","0.8267931","0.8262547","0.8249925","0.82311714","0.8218337","0.8209053","0.81681156","0.8161104","0.81400317","0.8131461","0.81231254","0.8110287","0.80916226","0.74270463","0.6780553","0.67750645","0.6743705","0.6661439","0.66607875","0.66438156","0.66315037","0.653206","0.65260327","0.63997895","0.6390869","0.63307774","0.63035846","0.62825966","0.6275895","0.62411445","0.62357366","0.62226886","0.62197226","0.6198424","0.6181772","0.61772877","0.6106023","0.6102432","0.60985005","0.6098051","0.6098051","0.60870284","0.60854197","0.608359","0.6075392","0.6072889","0.6059041","0.60570574","0.60490716","0.60482717","0.6037177","0.60346925","0.60247916","0.6021133","0.6012163","0.6012086","0.6010087","0.599621","0.5993492","0.59613234","0.59359604","0.5915945","0.59146976","0.59053916","0.58922523","0.58908916","0.58908916","0.58908916","0.5884495","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.58828765","0.5879422","0.5878966","0.5874437","0.5874437","0.5868832","0.5858793","0.5858793","0.5858793","0.585429","0.5852532","0.584704","0.5846784","0.5840537","0.5831427","0.5824777","0.5819348"],"string":"[\n \"0.841099\",\n \"0.841099\",\n \"0.8314405\",\n \"0.8295821\",\n \"0.8295821\",\n \"0.8267931\",\n \"0.8262547\",\n \"0.8249925\",\n \"0.82311714\",\n \"0.8218337\",\n \"0.8209053\",\n \"0.81681156\",\n \"0.8161104\",\n \"0.81400317\",\n \"0.8131461\",\n \"0.81231254\",\n \"0.8110287\",\n \"0.80916226\",\n \"0.74270463\",\n \"0.6780553\",\n \"0.67750645\",\n \"0.6743705\",\n \"0.6661439\",\n \"0.66607875\",\n \"0.66438156\",\n \"0.66315037\",\n \"0.653206\",\n \"0.65260327\",\n \"0.63997895\",\n \"0.6390869\",\n \"0.63307774\",\n \"0.63035846\",\n \"0.62825966\",\n \"0.6275895\",\n \"0.62411445\",\n \"0.62357366\",\n \"0.62226886\",\n \"0.62197226\",\n \"0.6198424\",\n \"0.6181772\",\n \"0.61772877\",\n \"0.6106023\",\n \"0.6102432\",\n \"0.60985005\",\n \"0.6098051\",\n \"0.6098051\",\n \"0.60870284\",\n \"0.60854197\",\n \"0.608359\",\n \"0.6075392\",\n \"0.6072889\",\n \"0.6059041\",\n \"0.60570574\",\n \"0.60490716\",\n \"0.60482717\",\n \"0.6037177\",\n \"0.60346925\",\n \"0.60247916\",\n \"0.6021133\",\n \"0.6012163\",\n \"0.6012086\",\n \"0.6010087\",\n \"0.599621\",\n \"0.5993492\",\n \"0.59613234\",\n \"0.59359604\",\n \"0.5915945\",\n \"0.59146976\",\n \"0.59053916\",\n \"0.58922523\",\n \"0.58908916\",\n \"0.58908916\",\n \"0.58908916\",\n \"0.5884495\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.58828765\",\n \"0.5879422\",\n \"0.5878966\",\n \"0.5874437\",\n \"0.5874437\",\n \"0.5868832\",\n \"0.5858793\",\n \"0.5858793\",\n \"0.5858793\",\n \"0.585429\",\n \"0.5852532\",\n \"0.584704\",\n \"0.5846784\",\n \"0.5840537\",\n \"0.5831427\",\n \"0.5824777\",\n \"0.5819348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81934065"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":9495,"cells":{"query":{"kind":"string","value":"Method that writes the JSON string representation of list_objs to a file"},"document":{"kind":"string","value":"def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n result = []\n if list_objs:\n for objs in list_objs:\n dictionary = objs.to_dictionary()\n result.append(dictionary)\n with open(filename, \"w\", encoding=\"utf-8\") as file:\n file.write(cls.to_json_string(result))"},"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 save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n with open(filename, \"w\") as f:\n if list_objs is None:\n f.write(\"[]\")\n else:\n d = [x.to_dictionary() for x in list_objs]\n f.write(Base.to_json_string(d))","def save_to_file(cls, list_objs):\n li = []\n with open(cls.__name__ + \".json\", mode=\"w\") as fl:\n if list_objs is None:\n fl.write(Base.to_json_string(list_objs))\n return\n for i in list_objs:\n li.append(i.to_dictionary())\n fl.write(Base.to_json_string(li))","def save_to_file(cls, list_objs):\n the_list = []\n if list_objs is not None:\n for stuff in list_objs:\n new_stuff = stuff.to_dictionary()\n the_list.append(new_stuff)\n the_list = Base.to_json_string(the_list)\n with open(\"{}.json\".format(cls.__name__), mode='w') as f:\n f.write(str(the_list))","def save_to_file(cls, list_objs):\n l = []\n if list_objs is not None:\n for item in list_objs:\n l.append(item.to_dictionary())\n with open(\"%s.json\" % cls.__name__, mode='w') as f:\n f.write(Base.to_json_string(l))","def save_to_file(cls, list_objs):\n filen = cls.__name__ + \".json\"\n\n list = []\n if list_objs is not None:\n for i in list_objs:\n i = i.to_dictionary()\n json_dict = json.loads(cls.to_json_string(i))\n list.append(json_dict)\n\n with open(filen, \"w\") as fd:\n json.dump(list, fd)","def save_to_file(cls, list_objs):\n my_list = []\n if list_objs or list_objs is not None:\n my_list = [obj.to_dictionary() for obj in list_objs]\n with open(cls.__name__ + '.json', 'w+') as f:\n f.write(cls.to_json_string(my_list))","def save_to_file(cls, list_objs):\n file = cls.__name__ + '.json'\n with open(file, 'w') as json_file:\n if list_objs is None:\n json_file.write('[]')\n else:\n dic = [obj.to_dictionary() for obj in list_objs]\n json_file.write(Base.to_json_string(dic))","def save_to_file(cls, list_objs):\n\n filename = cls.__name__ + \".json\"\n list_of_dictionaries = []\n for items in list_objs:\n list_of_dictionaries.append(items.to_dictionary())\n jsonstr = cls.to_json_string(list_of_dictionaries)\n with open(filename, 'w') as f:\n f.write(jsonstr)","def save_to_file(cls, list_objs):\n with open(cls.__name__ + \".json\", 'w') as my_file:\n if list_objs is None:\n json.dump([], my_file)\n\n else:\n list_of_dict = []\n for dictionary in list_objs:\n list_of_dict.append(dictionary.to_dictionary())\n j_list_objs = Base.to_json_string(list_of_dict)\n my_file.write(j_list_objs)\n return (my_file)","def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n new_list = []\n with open(filename, \"w\") as fp:\n if list_objs is None:\n fp.write(\"[]\")\n else:\n for objs in list_objs:\n new_list.append(cls.to_dictionary(objs))\n fp.write(cls.to_json_string(new_list))","def save_to_file(cls, list_objs):\n if list_objs is not None:\n list_objs = [obj.to_dictionary() for obj in list_objs]\n with open(\"{}.json\".format(cls.__name__), \"w\", encoding=\"utf-8\") as f:\n f.write(cls.to_json_string(list_objs))","def save_to_file(cls, list_objs):\n\n with open(cls.__name__ + \".json\", 'w') as f:\n l = []\n if list_objs is None or len(list_objs) <= 0:\n f.write(Base.to_json_string(l))\n\n else:\n for obj in list_objs:\n l.append(cls.to_dictionary(obj))\n f.write(Base.to_json_string(l))","def save_to_file(cls, list_objs):\n d = []\n with open(cls.__name__ + \".json\", \"w\", encoding=\"utf-8\") as f:\n if list_objs:\n for obj in list_objs:\n d.append(obj.to_dictionary())\n f.write(cls.to_json_string(d))","def save_to_file(cls, list_objs):\n\n tmp = []\n tmptwo = \"{}.json\".format(cls.__name__)\n if list_objs is not None:\n for i in range(len(list_objs)):\n tmp.append(cls.to_dictionary(list_objs[i]))\n with open(tmptwo, mode='w', encoding=\"utf-8\") as json_file:\n json_file.write(cls.to_json_string(tmp))","def save_to_file(cls, list_objs):\n namefile = cls.__name__ + \".json\"\n rep_list = []\n if list_objs is not None and list_objs != []:\n for item in list_objs:\n repre = cls.to_dictionary(item)\n # rep_list.append(cls.to_json_string(repre))\n rep_list.append(repre)\n\n with open(namefile, \"w\", encoding=\"UTF-8\") as f:\n # json.dump(rep_list, f)\n f.write(cls.to_json_string(rep_list))","def save_to_file(cls, list_objs):\n\n lis = []\n if list_objs is None:\n js_dic = cls.to_json_string(lis)\n with open(cls.__name__ + \".json\", encoding=\"utf-8\",\n mode=\"w\") as myFile:\n myFile.write(js_dic)\n else:\n for li in list_objs:\n lis.append(li.to_dictionary())\n js_dic = cls.to_json_string(lis)\n with open(cls.__name__ + \".json\", encoding=\"utf-8\",\n mode=\"w\") as myFile:\n myFile.write(js_dic)","def save_to_file(cls, list_objs):\n filename = cls.__name__\n dictt = []\n if list_objs:\n for i in list_objs:\n dictt.append(cls.to_dictionary(i))\n\n with open(filename + \".json\", \"w\") as myfile:\n myfile.write(cls.to_json_string(dictt))","def save_to_file(cls, list_objs):\n list_dicts = []\n filename = \"{}.json\".format(cls.__name__)\n\n if list_objs is not None:\n for obj in list_objs:\n list_dicts.append(cls.to_dictionary(obj))\n json_string = Base.to_json_string(list_dicts)\n with open(filename, mode='w+', encoding='utf-8') as file:\n file.write(json_string)","def save_to_file(cls, list_objs):\n objs = []\n filename = cls.__name__ + \".json\"\n if list_objs is not None:\n for ob in list_objs:\n objs.append(cls.to_dictionary(ob))\n with open(filename, \"w\") as f:\n f.write(cls.to_json_string(objs))","def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n listOfDict = []\n if list_objs is not None:\n for objs in list_objs:\n listOfDict.append(cls.to_dictionary(objs))\n with open(filename, \"w\") as f:\n f.write(cls.to_json_string(listOfDict))","def save_to_file(cls, list_objs):\n list_dictionaries = []\n if list_objs is None or list_objs == []:\n string_dictionary = \"[]\"\n else:\n for _obj_dict in list_objs:\n list_dictionaries.append(_obj_dict.to_dictionary())\n string_dictionary = Base.to_json_string(list_dictionaries)\n with open(cls.__name__ + \".json\", \"w\") as _file:\n _file.write(string_dictionary)\n _file.close()","def save_to_file(cls, list_objs):\n list_dictionaries = []\n if list_objs is None:\n with open(cls.__name__ + \".json\", \"w\", encoding='utf-8') as file:\n file.write(Base.to_json_string(list_dictionaries))\n return\n for model in list_objs:\n list_dictionaries.append(model.to_dictionary())\n with open(cls.__name__ + \".json\", \"w\", encoding='utf-8') as file:\n file.write(Base.to_json_string(list_dictionaries))","def save_to_file_csv(cls, list_objs):\n l = []\n if list_objs is not None:\n for item in list_objs:\n l.append(item.to_dictionary())\n with open(\"%s.csv\" % cls.__name__, mode='w') as f:\n f.write(Base.to_json_string(l))","def writeToFile(jsonList):\n file = open(\"data.json\", \"w\")\n file.write(json.dumps(jsonList, sort_keys=True, indent=4, separators=(',', ': ')))\n print(\"File written\")","def write_list_to_file(program, list_to_write):\n with open(program.split('.')[0] + \".output.json\", 'a+') as output_file:\n output_file.write(json.dumps(list_to_write, indent=3, sort_keys=False))","def save_to_file_csv(cls, list_objs):\n list_dictionaries = []\n if list_objs is None or list_objs == []:\n string_dictionary = \"[]\"\n else:\n for _obj_dict in list_objs:\n list_dictionaries.append(_obj_dict.to_dictionary())\n string_dictionary = Base.to_json_string(list_dictionaries)\n with open(cls.__name__ + \".csv\", \"w\") as _file:\n _file.write(string_dictionary)\n _file.close()","def save_json(ls, file_path):\n with open(file_path, 'w') as fp:\n fp.write('\\n'.join(json.dumps(i) for i in ls))","def output_jsonl(filename: str, data: List):\n with open(filename, \"w\") as outfile:\n for x in data:\n print(json.dumps(x))\n json.dump(x, outfile)\n outfile.write(\"\\n\")","def save_server_list_json(server_list):\n\n with open(output_file,\"w+\") as f:\n json.dump(server_list, f)\n\n return server_list","def list_to_json(input_list, file_name):\n with open(file_name, 'w') as outfile:\n json.dump(input_list, outfile)","def _write_json(\n output_path, records\n):\n output_path.write_text(json.dumps(records))","def save_to_file_csv(cls, list_objs):\n f_name = cls.__name__ + \".csv\"\n with open(f_name, 'w', newline='') as f:\n if list_objs is None or list_objs == []:\n f.write(\"[]\")\n\n else:\n if cls.__name__ == 'Rectangle':\n h = ['id', 'width', 'height', 'x', 'y']\n else:\n h = ['id', 'size', 'x', 'y']\n ncsv = csv.DictWriter(f, fieldnames=h)\n for obj in list_objs:\n ncsv.writerow(obj.to_dictionary())","def save_to_json(self, dict_list, filename):\n try:\n with open(filename + \".json\", \"w\") as outfile:\n dump(dict_list, outfile)\n return True\n except:\n return False","def save_json(file_name: str, content: list):\n with open(file_name, \"w+\") as file_object:\n json.dump(content, file_object)","def save_list_to_file(the_list, filepath):\n with open(filepath, 'w') as file_handler:\n for item in the_list:\n file_handler.write(\"{}\\n\".format(item))","def export_server_list_json(server_list, filename):\n\n with open(filename,\"w+\") as f:\n json.dump(server_list, f)\n\n return server_list","def write_json_file(file_name: str, content: list):\n with open(file_name, 'w+') as file_object:\n json.dump(content, file_object)","def save_to_file(todoList, doneList):\n\n filePath = os.path.expanduser('~/todoSave')\n f = open(filePath, 'w+')\n # wipe the old save file\n f.truncate(0)\n\n\n obj = {\"todo\": todoList, \"done\": doneList}\n f.write(json.dumps(obj, indent=4))","def writeToJson(inputObj,fileLoc):\n myFile = open(fileLoc,'w')\n json.dump(inputObj, myFile, sort_keys=True, indent=4, separators=(',', ': '))","def __save_txt(self, output_path: str, content: List[str]) -> None:\n file = open(output_path, \"w\")\n file.write(str(json.dumps(content)) + \"\\n\")\n file.close()","def write_json(obj_to_write: Any, filename: str):\n \n with open(filename, 'w') as json_file:\n json.dump(obj_to_write, json_file, indent=4)","def write_json_to_file(json_data: list, filename: str) -> None:\n print('Saving json data to ' + filename + '... ', end='', flush=True)\n with open(filename, 'w') as fd:\n json.dump(obj=json_data, fp=fd, ensure_ascii=False, indent=2)\n print('Done.')\n return","def save_data_to_file(file_name, list_of_product_objects):\r\n objfile = open(file_name, 'w')\r\n for row in list_of_product_objects:\r\n objfile.write(row.product_name + \",\" + str(row.product_price) + \"\\n\")\r\n objfile.close()","def save_to_json_file(my_obj, filename):\n with open(filename, \"w\") as myfile:\n return myfile.write(json.dumps(my_obj))","def save_data_to_file(file_name, list_of_product_objects):\r\n try:\r\n objF = open(file_name, \"w\")\r\n for row in list_of_product_objects:\r\n objF.write(str(row[0]) + \",\" + str(row[1]) + \"\\n\")\r\n objF.close()\r\n except IOError:\r\n print(\"Unable to locate file\")","def save_to_file_csv(cls, list_objs):\n with open(cls.__name__ + \".csv\", \"w\", newline='') as f:\n if cls.__name__ == \"Rectangle\":\n fieldnames = ['id', 'width', 'height', 'x', 'y']\n elif cls.__name__ == \"Square\":\n fieldnames = ['id', 'size', 'x', 'y']\n writer = csv.DictWriter(f, fieldnames=fieldnames)\n writer.writeheader()\n if list_objs is not None:\n for model in list_objs:\n writer.writerow(model.to_dictionary())","def save_users(user_list):\n with open(user_path, \"w\") as outfile:\n json.dump(user_list, outfile)","def save_to_file_csv(cls, list_objs):\n r_fields = ['id', 'width', 'height', 'x', 'y']\n s_fields = ['id', 'size', 'x', 'y']\n filename = cls.__name__ + \".csv\"\n new_list = []\n with open(filename, \"w\") as fp:\n if cls.__name__ == \"Rectangle\":\n dict_writer = csv.DictWriter(fp, fieldnames=r_fields)\n elif cls.__name__ == \"Square\":\n dict_writer = csv.DictWriter(fp, fieldnames=s_fields)\n dict_writer.writeheader()\n for objs in list_objs:\n dict_writer.writerow(objs.to_dictionary())","def save_to_json_file(my_obj, filename):\n with open(filename, \"w\") as f:\n j = json.dumps(my_obj)\n f.write(j)\n f.close()","def write_json(obj, fpath):\n mkdir_if_missing(osp.dirname(fpath))\n with open(fpath, 'w', encoding='utf-8') as f:\n json.dump(obj, f, indent=4, separators=(',', ': '), ensure_ascii=False) # 添加中文支持","def save_to_json_file(my_obj, filename):\n with open(filename, mode='w') as file:\n file.write(json.dumps(my_obj))","def save_to_json_file(my_obj, filename):\n with open(filename, 'w') as json_file:\n written = json_file.write(json.dumps(my_obj))\n return written","def save_to_json_file(my_obj, filename):\n with open(filename, 'w', encoding='utf-8') as file:\n return file.write(json.dumps(my_obj))","def write_json_file(self, fname, content):\n pass","def write_json_file(self, fname, content):\n pass","def write(lst):\n # TODO","def write_data(data):\r\n\r\n db = open(os.getcwd() + \"/www/access_list.txt\", 'w')\r\n json.dump(dict(data), db)","def dump_jsonl(self, data, output_path, append=False):\n mode = 'a+' if append else 'w'\n with open(output_path, mode, encoding='utf-8') as f:\n for line in data:\n json_record = json.dumps(line, ensure_ascii=False)\n f.write(json_record + '\\n')\n print('Wrote {} records to {}'.format(len(data), output_path))","def save_to_json_file(my_obj, filename):\n import json\n with open(filename, 'w', encoding='utf-8') as f:\n obj = json.dumps(my_obj)\n f.write(obj)","def write_json(self, obj, mode='wb', **kwargs):\n with self.open(mode) as f:\n return json.dump(obj, f, **kwargs)","def _write_json(self):\n with open(self._file_path, 'w') as f:\n json.dump(self._content, f, indent=4, separators=None,\n encoding='utf-8', sort_keys=False)","def write_list_to_file(file_name: str, list_name: List[str]):\n # Write to a file, overwriting the old contents\n file = open(file_name, 'w')\n\n # Loop through the list, append a newline character to each line\n for item in list_name:\n file.writelines(item + '\\n')\n\n # Close the file\n file.close()","def write(self):\n self.json_o.write()","def save_to_json_file(my_obj, filename):\n with open(filename, mode=\"w\", encoding=\"utf-8\") as writer:\n json.dump(my_obj, writer)","def save_to_json_file(my_obj, filename):\n with open(filename, 'w') as file:\n json.dump(my_obj, file)","def save_to_json_file(my_obj, filename):\n import json\n with open(filename, 'w') as file:\n json.dump(my_obj, file)","def delimited_write(self, obj):\n try:\n self.obj.write(\",\" + json.dumps(obj))\n except:\n self.bad_obj(obj)","def save_to_json_file(my_obj, filename):\n import json\n with open(filename, mode='w', encoding='utf-8') as f:\n json.dump(my_obj, f)","def save_to_json_file(my_obj, filename):\n with open(filename, \"w\", encoding=\"utf-8\") as opening:\n json.dump(my_obj, opening)","def to_json_file(test_health_list: List[TestHealthInfo],\n output_path: pathlib.Path) -> None:\n test_health_dicts = _to_test_health_dicts(test_health_list)\n\n with open(output_path, 'w') as json_file:\n for test_health in test_health_dicts:\n json.dump(test_health, json_file, allow_nan=False)\n json_file.write('\\n')","def save_to_file_csv(cls, list_objs):\n list_rectangle = [\"id\", \"width\", \"height\", \"x\", \"y\"]\n list_square = [\"id\", \"size\", \"x\", \"y\"]\n filename = cls.__name__ + \".csv\"\n result = []\n\n if list_objs:\n for objs in list_objs:\n # First recollect the info of the object with a dict\n dictionary = objs.to_dictionary()\n middle_result = []\n # Second obtein the values in a ordered class list\n if cls.__name__ == \"Rectangle\":\n for item in list_rectangle:\n middle_result.append(dictionary[item])\n if cls.__name__ == \"Square\":\n for item in list_square:\n middle_result.append(dictionary[item])\n # append the list to result list\n result.append(middle_result)\n with open(filename, \"w\", encoding=\"utf-8\") as file:\n writer = csv.writer(file)\n writer.writerows(result)","def save_to_json_file(my_obj, filename):\n with open(filename, 'w+') as json_file:\n json.dump(my_obj, json_file)","def write_list_to_file(myList, filename):\r\n\r\n with open(filename, \"w\") as outfile:\r\n for entries in myList:\r\n outfile.write(entries)\r\n\t\t\t# add a return after each line\r\n outfile.write(\"\\n\")","def save_list(lines, filename):\n data = '\\n'.join(lines)\n file = open(filename, 'w')\n file.write(data)\n file.close()","def save_data(data: typing.List[typing.Dict], filename: str):\n now = datetime.datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n with open(f\"{filename}-{now}.json\", \"w\") as f:\n f.write(json.dumps(data))","def save_to_file_csv(cls, list_objs):\n ld = []\n with open(cls.__name__ + \".csv\", \"w\", encoding=\"utf-8\") as f:\n if list_objs:\n for obj in list_objs:\n if cls.__name__ == 'Rectangle':\n ld.append([\n obj.id, obj.width, obj.height, obj.x, obj.y])\n if cls.__name__ == 'Square':\n ld.append([obj.id, obj.size, obj.x, obj.y])\n writer = csv.writer(f)\n for row in ld:\n writer.writerow(row)","def save(self):\n\n with open(FileStorage.__file_path, \"w\") as file:\n dictionary = {}\n for a, b in FileStorage.__objects.items():\n dictionary[a] = b.to_dict()\n ink = json.dumps(dictionary)\n file.write(ink)","def save_client_list_to_file(self):\n # cycle through clients and save each client into its own file\n for client in self.client_list:\n self.save_client_to_file(client=client)","def save_data(file_to_save, object_to_serialize):\r\n with open(file_to_save, \"w\", encoding=\"utf-8\") as f:\r\n f.write(json.dumps(object_to_serialize, indent=2, ensure_ascii=False))","def write_to_json(self, export_fp: str):\n # TODO:\n pass","def output_json(file_name, domain_object, output_dir):\n\n with open(path.join(output_dir, file_name + '.json'), 'w', encoding='utf-8', errors='replace') as out_file:\n json_object = jsonpickle.encode(domain_object)\n out_file.write(json_object)\n out_file.write('\\n')","def write_tojson(data, filename) -> None:\r\n with open(\"static/json/\" + filename, \"w\") as out:\r\n out.write(\r\n json.dumps(\r\n [data[datum].__dict__() for datum in data]\r\n )\r\n )","def __writeToFile(self, filePath, lst): \n \n if not self.outDir is None: \n filePath = os.path.join(self.outDir, filePath) \n \n open(filePath,'a').writelines(lst)","def write_list(args, file_list):\n if not args.listfile.endswith(\".txt\"):\n args.listfile += \".txt\"\n outputfile = open(args.listfile, 'w')\n for name in file_list:\n outputfile.write(name)\n outputfile.write(\"\\n\")\n outputfile.close()","def save_file(self):\n f = open(self._file_name, \"w\")\n try:\n for rental in self.list:\n rental_str = self.obj_to_string(rental)\n f.write(rental_str)\n f.close()\n except Exception as e:\n raise e","def dump_jsonl(data, output_path, append=False):\n mode = 'a+' if append else 'w'\n with open(output_path, mode, encoding='utf-8') as f:\n for line in data:\n json_record = json.dumps(line, ensure_ascii=False)\n f.write(json_record + '\\n')\n print('Wrote {} records to {}'.format(len(data), output_path))","def write(self):\r\n\r\n with open(self.filename + \".json\", mode='w') as json_file:\r\n json.dump(self.data, json_file, separators=(',', ':'))","def save_list(list_data, path, lineterminator='\\n', encoding=None, mode='w'):\n with open(path, mode) as f:\n list_data = [item + lineterminator for item in list_data]\n if encoding is not None:\n list_data = [item.encode(encoding) for item in list_data]\n\n f.writelines(list_data)","def save(self, filename):\n with open(filename, \"w\") as f:\n m = {\n \"order\": self.order,\n \"pad\": self.pad,\n \"records\": {str(k): v for k, v in self.records.items()}\n }\n json.dump(m, f)","def dump_to_json(fileinfos, out):\n jsonarray = json.dumps(fileinfos)\n json_filename = \"all_elements_used.json\"\n text_file = open(os.path.join(out,out_dir_name,json_filename), \"w\")\n text_file.write(jsonarray)\n text_file.close()\n stdout.write(\"... \"+json_filename+\" created\\n\")","def write_json(\n data: Any,\n filepath: types.PathLike,\n *,\n mode: str = \"wt\",\n encoding: Optional[str] = None,\n make_dirs: bool = False,\n lines: bool = False,\n ensure_ascii: bool = False,\n separators: tuple[str, str] = (\",\", \":\"),\n sort_keys: bool = False,\n indent: Optional[int | str] = None,\n) -> None:\n io_utils._validate_write_mode(mode)\n with io_utils.open_sesame(\n filepath, mode=mode, encoding=encoding, make_dirs=make_dirs\n ) as f:\n if lines is False:\n f.write(\n json.dumps(\n data,\n indent=indent,\n ensure_ascii=ensure_ascii,\n separators=separators,\n sort_keys=sort_keys,\n cls=ExtendedJSONEncoder,\n )\n )\n else:\n newline: Union[str, bytes] = \"\\n\" if \"t\" in mode else b\"\\n\"\n for item in data:\n f.write(\n json.dumps(\n item,\n indent=indent,\n ensure_ascii=ensure_ascii,\n separators=separators,\n sort_keys=sort_keys,\n cls=ExtendedJSONEncoder,\n )\n + newline\n )","def _write_content(i, content):\n fpath = io_mgr.get_parties_json(i)\n with open(fpath, 'w') as fstream:\n fstream.write(json.dumps(content, indent=4))","def _json_write(filename, res):\n with open(filename, 'w+') as file:\n return json.dump(res, file)","def write(self, obj):\n try:\n self.obj.write(json.dumps(obj))\n setattr(self, \"write\", self.delimited_write)\n except:\n self.bad_obj(obj)","def save_to_json(library: list, json_file_name) -> None:\n contents = convert_library_to_json(library)\n with open(json_file_name, 'w') as file_object:\n json.dump(contents, file_object)","def save(self, data, outpath):\n with open(path, \"wt\") as open_file:\n json.dump(data, open_file, indent=4)","def export_json(contents, filename):\n with open(filename, 'w') as f:\n json.dump(contents, f)","def list_to_file(l, file_name):\r\n fw = open(file_name, 'w', encoding = 'utf-8')\r\n fw.write('\\n'.join(l))\r\n fw.close()","def save_json(self, file: Union[str, TextIO]) -> None:\n if hasattr(file, 'write'):\n file_ctx = nullcontext(file)\n else:\n file_ctx = open(file, 'w')\n\n with file_ctx as fp:\n for d in self:\n json.dump(d.dict(), fp)\n fp.write('\\n')","def to_json_file(self, path: Union[str, Path]):\n data_dict = self._to_list_dict()\n return json.dump(data_dict, Path(path).open(\"w\", encoding=\"utf8\"), cls=NumpyEncoder, indent=4)"],"string":"[\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__ + \\\".json\\\"\\n with open(filename, \\\"w\\\") as f:\\n if list_objs is None:\\n f.write(\\\"[]\\\")\\n else:\\n d = [x.to_dictionary() for x in list_objs]\\n f.write(Base.to_json_string(d))\",\n \"def save_to_file(cls, list_objs):\\n li = []\\n with open(cls.__name__ + \\\".json\\\", mode=\\\"w\\\") as fl:\\n if list_objs is None:\\n fl.write(Base.to_json_string(list_objs))\\n return\\n for i in list_objs:\\n li.append(i.to_dictionary())\\n fl.write(Base.to_json_string(li))\",\n \"def save_to_file(cls, list_objs):\\n the_list = []\\n if list_objs is not None:\\n for stuff in list_objs:\\n new_stuff = stuff.to_dictionary()\\n the_list.append(new_stuff)\\n the_list = Base.to_json_string(the_list)\\n with open(\\\"{}.json\\\".format(cls.__name__), mode='w') as f:\\n f.write(str(the_list))\",\n \"def save_to_file(cls, list_objs):\\n l = []\\n if list_objs is not None:\\n for item in list_objs:\\n l.append(item.to_dictionary())\\n with open(\\\"%s.json\\\" % cls.__name__, mode='w') as f:\\n f.write(Base.to_json_string(l))\",\n \"def save_to_file(cls, list_objs):\\n filen = cls.__name__ + \\\".json\\\"\\n\\n list = []\\n if list_objs is not None:\\n for i in list_objs:\\n i = i.to_dictionary()\\n json_dict = json.loads(cls.to_json_string(i))\\n list.append(json_dict)\\n\\n with open(filen, \\\"w\\\") as fd:\\n json.dump(list, fd)\",\n \"def save_to_file(cls, list_objs):\\n my_list = []\\n if list_objs or list_objs is not None:\\n my_list = [obj.to_dictionary() for obj in list_objs]\\n with open(cls.__name__ + '.json', 'w+') as f:\\n f.write(cls.to_json_string(my_list))\",\n \"def save_to_file(cls, list_objs):\\n file = cls.__name__ + '.json'\\n with open(file, 'w') as json_file:\\n if list_objs is None:\\n json_file.write('[]')\\n else:\\n dic = [obj.to_dictionary() for obj in list_objs]\\n json_file.write(Base.to_json_string(dic))\",\n \"def save_to_file(cls, list_objs):\\n\\n filename = cls.__name__ + \\\".json\\\"\\n list_of_dictionaries = []\\n for items in list_objs:\\n list_of_dictionaries.append(items.to_dictionary())\\n jsonstr = cls.to_json_string(list_of_dictionaries)\\n with open(filename, 'w') as f:\\n f.write(jsonstr)\",\n \"def save_to_file(cls, list_objs):\\n with open(cls.__name__ + \\\".json\\\", 'w') as my_file:\\n if list_objs is None:\\n json.dump([], my_file)\\n\\n else:\\n list_of_dict = []\\n for dictionary in list_objs:\\n list_of_dict.append(dictionary.to_dictionary())\\n j_list_objs = Base.to_json_string(list_of_dict)\\n my_file.write(j_list_objs)\\n return (my_file)\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__ + \\\".json\\\"\\n new_list = []\\n with open(filename, \\\"w\\\") as fp:\\n if list_objs is None:\\n fp.write(\\\"[]\\\")\\n else:\\n for objs in list_objs:\\n new_list.append(cls.to_dictionary(objs))\\n fp.write(cls.to_json_string(new_list))\",\n \"def save_to_file(cls, list_objs):\\n if list_objs is not None:\\n list_objs = [obj.to_dictionary() for obj in list_objs]\\n with open(\\\"{}.json\\\".format(cls.__name__), \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n f.write(cls.to_json_string(list_objs))\",\n \"def save_to_file(cls, list_objs):\\n\\n with open(cls.__name__ + \\\".json\\\", 'w') as f:\\n l = []\\n if list_objs is None or len(list_objs) <= 0:\\n f.write(Base.to_json_string(l))\\n\\n else:\\n for obj in list_objs:\\n l.append(cls.to_dictionary(obj))\\n f.write(Base.to_json_string(l))\",\n \"def save_to_file(cls, list_objs):\\n d = []\\n with open(cls.__name__ + \\\".json\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n if list_objs:\\n for obj in list_objs:\\n d.append(obj.to_dictionary())\\n f.write(cls.to_json_string(d))\",\n \"def save_to_file(cls, list_objs):\\n\\n tmp = []\\n tmptwo = \\\"{}.json\\\".format(cls.__name__)\\n if list_objs is not None:\\n for i in range(len(list_objs)):\\n tmp.append(cls.to_dictionary(list_objs[i]))\\n with open(tmptwo, mode='w', encoding=\\\"utf-8\\\") as json_file:\\n json_file.write(cls.to_json_string(tmp))\",\n \"def save_to_file(cls, list_objs):\\n namefile = cls.__name__ + \\\".json\\\"\\n rep_list = []\\n if list_objs is not None and list_objs != []:\\n for item in list_objs:\\n repre = cls.to_dictionary(item)\\n # rep_list.append(cls.to_json_string(repre))\\n rep_list.append(repre)\\n\\n with open(namefile, \\\"w\\\", encoding=\\\"UTF-8\\\") as f:\\n # json.dump(rep_list, f)\\n f.write(cls.to_json_string(rep_list))\",\n \"def save_to_file(cls, list_objs):\\n\\n lis = []\\n if list_objs is None:\\n js_dic = cls.to_json_string(lis)\\n with open(cls.__name__ + \\\".json\\\", encoding=\\\"utf-8\\\",\\n mode=\\\"w\\\") as myFile:\\n myFile.write(js_dic)\\n else:\\n for li in list_objs:\\n lis.append(li.to_dictionary())\\n js_dic = cls.to_json_string(lis)\\n with open(cls.__name__ + \\\".json\\\", encoding=\\\"utf-8\\\",\\n mode=\\\"w\\\") as myFile:\\n myFile.write(js_dic)\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__\\n dictt = []\\n if list_objs:\\n for i in list_objs:\\n dictt.append(cls.to_dictionary(i))\\n\\n with open(filename + \\\".json\\\", \\\"w\\\") as myfile:\\n myfile.write(cls.to_json_string(dictt))\",\n \"def save_to_file(cls, list_objs):\\n list_dicts = []\\n filename = \\\"{}.json\\\".format(cls.__name__)\\n\\n if list_objs is not None:\\n for obj in list_objs:\\n list_dicts.append(cls.to_dictionary(obj))\\n json_string = Base.to_json_string(list_dicts)\\n with open(filename, mode='w+', encoding='utf-8') as file:\\n file.write(json_string)\",\n \"def save_to_file(cls, list_objs):\\n objs = []\\n filename = cls.__name__ + \\\".json\\\"\\n if list_objs is not None:\\n for ob in list_objs:\\n objs.append(cls.to_dictionary(ob))\\n with open(filename, \\\"w\\\") as f:\\n f.write(cls.to_json_string(objs))\",\n \"def save_to_file(cls, list_objs):\\n filename = cls.__name__ + \\\".json\\\"\\n listOfDict = []\\n if list_objs is not None:\\n for objs in list_objs:\\n listOfDict.append(cls.to_dictionary(objs))\\n with open(filename, \\\"w\\\") as f:\\n f.write(cls.to_json_string(listOfDict))\",\n \"def save_to_file(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None or list_objs == []:\\n string_dictionary = \\\"[]\\\"\\n else:\\n for _obj_dict in list_objs:\\n list_dictionaries.append(_obj_dict.to_dictionary())\\n string_dictionary = Base.to_json_string(list_dictionaries)\\n with open(cls.__name__ + \\\".json\\\", \\\"w\\\") as _file:\\n _file.write(string_dictionary)\\n _file.close()\",\n \"def save_to_file(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None:\\n with open(cls.__name__ + \\\".json\\\", \\\"w\\\", encoding='utf-8') as file:\\n file.write(Base.to_json_string(list_dictionaries))\\n return\\n for model in list_objs:\\n list_dictionaries.append(model.to_dictionary())\\n with open(cls.__name__ + \\\".json\\\", \\\"w\\\", encoding='utf-8') as file:\\n file.write(Base.to_json_string(list_dictionaries))\",\n \"def save_to_file_csv(cls, list_objs):\\n l = []\\n if list_objs is not None:\\n for item in list_objs:\\n l.append(item.to_dictionary())\\n with open(\\\"%s.csv\\\" % cls.__name__, mode='w') as f:\\n f.write(Base.to_json_string(l))\",\n \"def writeToFile(jsonList):\\n file = open(\\\"data.json\\\", \\\"w\\\")\\n file.write(json.dumps(jsonList, sort_keys=True, indent=4, separators=(',', ': ')))\\n print(\\\"File written\\\")\",\n \"def write_list_to_file(program, list_to_write):\\n with open(program.split('.')[0] + \\\".output.json\\\", 'a+') as output_file:\\n output_file.write(json.dumps(list_to_write, indent=3, sort_keys=False))\",\n \"def save_to_file_csv(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None or list_objs == []:\\n string_dictionary = \\\"[]\\\"\\n else:\\n for _obj_dict in list_objs:\\n list_dictionaries.append(_obj_dict.to_dictionary())\\n string_dictionary = Base.to_json_string(list_dictionaries)\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\") as _file:\\n _file.write(string_dictionary)\\n _file.close()\",\n \"def save_json(ls, file_path):\\n with open(file_path, 'w') as fp:\\n fp.write('\\\\n'.join(json.dumps(i) for i in ls))\",\n \"def output_jsonl(filename: str, data: List):\\n with open(filename, \\\"w\\\") as outfile:\\n for x in data:\\n print(json.dumps(x))\\n json.dump(x, outfile)\\n outfile.write(\\\"\\\\n\\\")\",\n \"def save_server_list_json(server_list):\\n\\n with open(output_file,\\\"w+\\\") as f:\\n json.dump(server_list, f)\\n\\n return server_list\",\n \"def list_to_json(input_list, file_name):\\n with open(file_name, 'w') as outfile:\\n json.dump(input_list, outfile)\",\n \"def _write_json(\\n output_path, records\\n):\\n output_path.write_text(json.dumps(records))\",\n \"def save_to_file_csv(cls, list_objs):\\n f_name = cls.__name__ + \\\".csv\\\"\\n with open(f_name, 'w', newline='') as f:\\n if list_objs is None or list_objs == []:\\n f.write(\\\"[]\\\")\\n\\n else:\\n if cls.__name__ == 'Rectangle':\\n h = ['id', 'width', 'height', 'x', 'y']\\n else:\\n h = ['id', 'size', 'x', 'y']\\n ncsv = csv.DictWriter(f, fieldnames=h)\\n for obj in list_objs:\\n ncsv.writerow(obj.to_dictionary())\",\n \"def save_to_json(self, dict_list, filename):\\n try:\\n with open(filename + \\\".json\\\", \\\"w\\\") as outfile:\\n dump(dict_list, outfile)\\n return True\\n except:\\n return False\",\n \"def save_json(file_name: str, content: list):\\n with open(file_name, \\\"w+\\\") as file_object:\\n json.dump(content, file_object)\",\n \"def save_list_to_file(the_list, filepath):\\n with open(filepath, 'w') as file_handler:\\n for item in the_list:\\n file_handler.write(\\\"{}\\\\n\\\".format(item))\",\n \"def export_server_list_json(server_list, filename):\\n\\n with open(filename,\\\"w+\\\") as f:\\n json.dump(server_list, f)\\n\\n return server_list\",\n \"def write_json_file(file_name: str, content: list):\\n with open(file_name, 'w+') as file_object:\\n json.dump(content, file_object)\",\n \"def save_to_file(todoList, doneList):\\n\\n filePath = os.path.expanduser('~/todoSave')\\n f = open(filePath, 'w+')\\n # wipe the old save file\\n f.truncate(0)\\n\\n\\n obj = {\\\"todo\\\": todoList, \\\"done\\\": doneList}\\n f.write(json.dumps(obj, indent=4))\",\n \"def writeToJson(inputObj,fileLoc):\\n myFile = open(fileLoc,'w')\\n json.dump(inputObj, myFile, sort_keys=True, indent=4, separators=(',', ': '))\",\n \"def __save_txt(self, output_path: str, content: List[str]) -> None:\\n file = open(output_path, \\\"w\\\")\\n file.write(str(json.dumps(content)) + \\\"\\\\n\\\")\\n file.close()\",\n \"def write_json(obj_to_write: Any, filename: str):\\n \\n with open(filename, 'w') as json_file:\\n json.dump(obj_to_write, json_file, indent=4)\",\n \"def write_json_to_file(json_data: list, filename: str) -> None:\\n print('Saving json data to ' + filename + '... ', end='', flush=True)\\n with open(filename, 'w') as fd:\\n json.dump(obj=json_data, fp=fd, ensure_ascii=False, indent=2)\\n print('Done.')\\n return\",\n \"def save_data_to_file(file_name, list_of_product_objects):\\r\\n objfile = open(file_name, 'w')\\r\\n for row in list_of_product_objects:\\r\\n objfile.write(row.product_name + \\\",\\\" + str(row.product_price) + \\\"\\\\n\\\")\\r\\n objfile.close()\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, \\\"w\\\") as myfile:\\n return myfile.write(json.dumps(my_obj))\",\n \"def save_data_to_file(file_name, list_of_product_objects):\\r\\n try:\\r\\n objF = open(file_name, \\\"w\\\")\\r\\n for row in list_of_product_objects:\\r\\n objF.write(str(row[0]) + \\\",\\\" + str(row[1]) + \\\"\\\\n\\\")\\r\\n objF.close()\\r\\n except IOError:\\r\\n print(\\\"Unable to locate file\\\")\",\n \"def save_to_file_csv(cls, list_objs):\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\", newline='') as f:\\n if cls.__name__ == \\\"Rectangle\\\":\\n fieldnames = ['id', 'width', 'height', 'x', 'y']\\n elif cls.__name__ == \\\"Square\\\":\\n fieldnames = ['id', 'size', 'x', 'y']\\n writer = csv.DictWriter(f, fieldnames=fieldnames)\\n writer.writeheader()\\n if list_objs is not None:\\n for model in list_objs:\\n writer.writerow(model.to_dictionary())\",\n \"def save_users(user_list):\\n with open(user_path, \\\"w\\\") as outfile:\\n json.dump(user_list, outfile)\",\n \"def save_to_file_csv(cls, list_objs):\\n r_fields = ['id', 'width', 'height', 'x', 'y']\\n s_fields = ['id', 'size', 'x', 'y']\\n filename = cls.__name__ + \\\".csv\\\"\\n new_list = []\\n with open(filename, \\\"w\\\") as fp:\\n if cls.__name__ == \\\"Rectangle\\\":\\n dict_writer = csv.DictWriter(fp, fieldnames=r_fields)\\n elif cls.__name__ == \\\"Square\\\":\\n dict_writer = csv.DictWriter(fp, fieldnames=s_fields)\\n dict_writer.writeheader()\\n for objs in list_objs:\\n dict_writer.writerow(objs.to_dictionary())\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, \\\"w\\\") as f:\\n j = json.dumps(my_obj)\\n f.write(j)\\n f.close()\",\n \"def write_json(obj, fpath):\\n mkdir_if_missing(osp.dirname(fpath))\\n with open(fpath, 'w', encoding='utf-8') as f:\\n json.dump(obj, f, indent=4, separators=(',', ': '), ensure_ascii=False) # 添加中文支持\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, mode='w') as file:\\n file.write(json.dumps(my_obj))\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, 'w') as json_file:\\n written = json_file.write(json.dumps(my_obj))\\n return written\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, 'w', encoding='utf-8') as file:\\n return file.write(json.dumps(my_obj))\",\n \"def write_json_file(self, fname, content):\\n pass\",\n \"def write_json_file(self, fname, content):\\n pass\",\n \"def write(lst):\\n # TODO\",\n \"def write_data(data):\\r\\n\\r\\n db = open(os.getcwd() + \\\"/www/access_list.txt\\\", 'w')\\r\\n json.dump(dict(data), db)\",\n \"def dump_jsonl(self, data, output_path, append=False):\\n mode = 'a+' if append else 'w'\\n with open(output_path, mode, encoding='utf-8') as f:\\n for line in data:\\n json_record = json.dumps(line, ensure_ascii=False)\\n f.write(json_record + '\\\\n')\\n print('Wrote {} records to {}'.format(len(data), output_path))\",\n \"def save_to_json_file(my_obj, filename):\\n import json\\n with open(filename, 'w', encoding='utf-8') as f:\\n obj = json.dumps(my_obj)\\n f.write(obj)\",\n \"def write_json(self, obj, mode='wb', **kwargs):\\n with self.open(mode) as f:\\n return json.dump(obj, f, **kwargs)\",\n \"def _write_json(self):\\n with open(self._file_path, 'w') as f:\\n json.dump(self._content, f, indent=4, separators=None,\\n encoding='utf-8', sort_keys=False)\",\n \"def write_list_to_file(file_name: str, list_name: List[str]):\\n # Write to a file, overwriting the old contents\\n file = open(file_name, 'w')\\n\\n # Loop through the list, append a newline character to each line\\n for item in list_name:\\n file.writelines(item + '\\\\n')\\n\\n # Close the file\\n file.close()\",\n \"def write(self):\\n self.json_o.write()\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, mode=\\\"w\\\", encoding=\\\"utf-8\\\") as writer:\\n json.dump(my_obj, writer)\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, 'w') as file:\\n json.dump(my_obj, file)\",\n \"def save_to_json_file(my_obj, filename):\\n import json\\n with open(filename, 'w') as file:\\n json.dump(my_obj, file)\",\n \"def delimited_write(self, obj):\\n try:\\n self.obj.write(\\\",\\\" + json.dumps(obj))\\n except:\\n self.bad_obj(obj)\",\n \"def save_to_json_file(my_obj, filename):\\n import json\\n with open(filename, mode='w', encoding='utf-8') as f:\\n json.dump(my_obj, f)\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as opening:\\n json.dump(my_obj, opening)\",\n \"def to_json_file(test_health_list: List[TestHealthInfo],\\n output_path: pathlib.Path) -> None:\\n test_health_dicts = _to_test_health_dicts(test_health_list)\\n\\n with open(output_path, 'w') as json_file:\\n for test_health in test_health_dicts:\\n json.dump(test_health, json_file, allow_nan=False)\\n json_file.write('\\\\n')\",\n \"def save_to_file_csv(cls, list_objs):\\n list_rectangle = [\\\"id\\\", \\\"width\\\", \\\"height\\\", \\\"x\\\", \\\"y\\\"]\\n list_square = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n filename = cls.__name__ + \\\".csv\\\"\\n result = []\\n\\n if list_objs:\\n for objs in list_objs:\\n # First recollect the info of the object with a dict\\n dictionary = objs.to_dictionary()\\n middle_result = []\\n # Second obtein the values in a ordered class list\\n if cls.__name__ == \\\"Rectangle\\\":\\n for item in list_rectangle:\\n middle_result.append(dictionary[item])\\n if cls.__name__ == \\\"Square\\\":\\n for item in list_square:\\n middle_result.append(dictionary[item])\\n # append the list to result list\\n result.append(middle_result)\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as file:\\n writer = csv.writer(file)\\n writer.writerows(result)\",\n \"def save_to_json_file(my_obj, filename):\\n with open(filename, 'w+') as json_file:\\n json.dump(my_obj, json_file)\",\n \"def write_list_to_file(myList, filename):\\r\\n\\r\\n with open(filename, \\\"w\\\") as outfile:\\r\\n for entries in myList:\\r\\n outfile.write(entries)\\r\\n\\t\\t\\t# add a return after each line\\r\\n outfile.write(\\\"\\\\n\\\")\",\n \"def save_list(lines, filename):\\n data = '\\\\n'.join(lines)\\n file = open(filename, 'w')\\n file.write(data)\\n file.close()\",\n \"def save_data(data: typing.List[typing.Dict], filename: str):\\n now = datetime.datetime.now().strftime(\\\"%Y-%m-%d_%H-%M-%S\\\")\\n with open(f\\\"{filename}-{now}.json\\\", \\\"w\\\") as f:\\n f.write(json.dumps(data))\",\n \"def save_to_file_csv(cls, list_objs):\\n ld = []\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n if list_objs:\\n for obj in list_objs:\\n if cls.__name__ == 'Rectangle':\\n ld.append([\\n obj.id, obj.width, obj.height, obj.x, obj.y])\\n if cls.__name__ == 'Square':\\n ld.append([obj.id, obj.size, obj.x, obj.y])\\n writer = csv.writer(f)\\n for row in ld:\\n writer.writerow(row)\",\n \"def save(self):\\n\\n with open(FileStorage.__file_path, \\\"w\\\") as file:\\n dictionary = {}\\n for a, b in FileStorage.__objects.items():\\n dictionary[a] = b.to_dict()\\n ink = json.dumps(dictionary)\\n file.write(ink)\",\n \"def save_client_list_to_file(self):\\n # cycle through clients and save each client into its own file\\n for client in self.client_list:\\n self.save_client_to_file(client=client)\",\n \"def save_data(file_to_save, object_to_serialize):\\r\\n with open(file_to_save, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\r\\n f.write(json.dumps(object_to_serialize, indent=2, ensure_ascii=False))\",\n \"def write_to_json(self, export_fp: str):\\n # TODO:\\n pass\",\n \"def output_json(file_name, domain_object, output_dir):\\n\\n with open(path.join(output_dir, file_name + '.json'), 'w', encoding='utf-8', errors='replace') as out_file:\\n json_object = jsonpickle.encode(domain_object)\\n out_file.write(json_object)\\n out_file.write('\\\\n')\",\n \"def write_tojson(data, filename) -> None:\\r\\n with open(\\\"static/json/\\\" + filename, \\\"w\\\") as out:\\r\\n out.write(\\r\\n json.dumps(\\r\\n [data[datum].__dict__() for datum in data]\\r\\n )\\r\\n )\",\n \"def __writeToFile(self, filePath, lst): \\n \\n if not self.outDir is None: \\n filePath = os.path.join(self.outDir, filePath) \\n \\n open(filePath,'a').writelines(lst)\",\n \"def write_list(args, file_list):\\n if not args.listfile.endswith(\\\".txt\\\"):\\n args.listfile += \\\".txt\\\"\\n outputfile = open(args.listfile, 'w')\\n for name in file_list:\\n outputfile.write(name)\\n outputfile.write(\\\"\\\\n\\\")\\n outputfile.close()\",\n \"def save_file(self):\\n f = open(self._file_name, \\\"w\\\")\\n try:\\n for rental in self.list:\\n rental_str = self.obj_to_string(rental)\\n f.write(rental_str)\\n f.close()\\n except Exception as e:\\n raise e\",\n \"def dump_jsonl(data, output_path, append=False):\\n mode = 'a+' if append else 'w'\\n with open(output_path, mode, encoding='utf-8') as f:\\n for line in data:\\n json_record = json.dumps(line, ensure_ascii=False)\\n f.write(json_record + '\\\\n')\\n print('Wrote {} records to {}'.format(len(data), output_path))\",\n \"def write(self):\\r\\n\\r\\n with open(self.filename + \\\".json\\\", mode='w') as json_file:\\r\\n json.dump(self.data, json_file, separators=(',', ':'))\",\n \"def save_list(list_data, path, lineterminator='\\\\n', encoding=None, mode='w'):\\n with open(path, mode) as f:\\n list_data = [item + lineterminator for item in list_data]\\n if encoding is not None:\\n list_data = [item.encode(encoding) for item in list_data]\\n\\n f.writelines(list_data)\",\n \"def save(self, filename):\\n with open(filename, \\\"w\\\") as f:\\n m = {\\n \\\"order\\\": self.order,\\n \\\"pad\\\": self.pad,\\n \\\"records\\\": {str(k): v for k, v in self.records.items()}\\n }\\n json.dump(m, f)\",\n \"def dump_to_json(fileinfos, out):\\n jsonarray = json.dumps(fileinfos)\\n json_filename = \\\"all_elements_used.json\\\"\\n text_file = open(os.path.join(out,out_dir_name,json_filename), \\\"w\\\")\\n text_file.write(jsonarray)\\n text_file.close()\\n stdout.write(\\\"... \\\"+json_filename+\\\" created\\\\n\\\")\",\n \"def write_json(\\n data: Any,\\n filepath: types.PathLike,\\n *,\\n mode: str = \\\"wt\\\",\\n encoding: Optional[str] = None,\\n make_dirs: bool = False,\\n lines: bool = False,\\n ensure_ascii: bool = False,\\n separators: tuple[str, str] = (\\\",\\\", \\\":\\\"),\\n sort_keys: bool = False,\\n indent: Optional[int | str] = None,\\n) -> None:\\n io_utils._validate_write_mode(mode)\\n with io_utils.open_sesame(\\n filepath, mode=mode, encoding=encoding, make_dirs=make_dirs\\n ) as f:\\n if lines is False:\\n f.write(\\n json.dumps(\\n data,\\n indent=indent,\\n ensure_ascii=ensure_ascii,\\n separators=separators,\\n sort_keys=sort_keys,\\n cls=ExtendedJSONEncoder,\\n )\\n )\\n else:\\n newline: Union[str, bytes] = \\\"\\\\n\\\" if \\\"t\\\" in mode else b\\\"\\\\n\\\"\\n for item in data:\\n f.write(\\n json.dumps(\\n item,\\n indent=indent,\\n ensure_ascii=ensure_ascii,\\n separators=separators,\\n sort_keys=sort_keys,\\n cls=ExtendedJSONEncoder,\\n )\\n + newline\\n )\",\n \"def _write_content(i, content):\\n fpath = io_mgr.get_parties_json(i)\\n with open(fpath, 'w') as fstream:\\n fstream.write(json.dumps(content, indent=4))\",\n \"def _json_write(filename, res):\\n with open(filename, 'w+') as file:\\n return json.dump(res, file)\",\n \"def write(self, obj):\\n try:\\n self.obj.write(json.dumps(obj))\\n setattr(self, \\\"write\\\", self.delimited_write)\\n except:\\n self.bad_obj(obj)\",\n \"def save_to_json(library: list, json_file_name) -> None:\\n contents = convert_library_to_json(library)\\n with open(json_file_name, 'w') as file_object:\\n json.dump(contents, file_object)\",\n \"def save(self, data, outpath):\\n with open(path, \\\"wt\\\") as open_file:\\n json.dump(data, open_file, indent=4)\",\n \"def export_json(contents, filename):\\n with open(filename, 'w') as f:\\n json.dump(contents, f)\",\n \"def list_to_file(l, file_name):\\r\\n fw = open(file_name, 'w', encoding = 'utf-8')\\r\\n fw.write('\\\\n'.join(l))\\r\\n fw.close()\",\n \"def save_json(self, file: Union[str, TextIO]) -> None:\\n if hasattr(file, 'write'):\\n file_ctx = nullcontext(file)\\n else:\\n file_ctx = open(file, 'w')\\n\\n with file_ctx as fp:\\n for d in self:\\n json.dump(d.dict(), fp)\\n fp.write('\\\\n')\",\n \"def to_json_file(self, path: Union[str, Path]):\\n data_dict = self._to_list_dict()\\n return json.dump(data_dict, Path(path).open(\\\"w\\\", encoding=\\\"utf8\\\"), cls=NumpyEncoder, indent=4)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.86339736","0.8606109","0.8603492","0.85995936","0.8557784","0.8546807","0.85401046","0.8516957","0.8511827","0.84710205","0.84403396","0.8420791","0.8380287","0.8351859","0.83487356","0.8338624","0.832877","0.82504755","0.824626","0.8242384","0.8223594","0.79081684","0.7731949","0.7693404","0.7634081","0.74502015","0.7342762","0.71266776","0.7049452","0.69970644","0.69469595","0.687617","0.68724865","0.68673515","0.6852626","0.6849195","0.683367","0.6748739","0.67290497","0.6617615","0.65847963","0.6584383","0.6578199","0.65496385","0.6546174","0.6544184","0.65305346","0.65281457","0.6494542","0.6491491","0.64771223","0.6461849","0.64503425","0.64446306","0.64446306","0.6435211","0.64304614","0.6424253","0.6399783","0.6362248","0.63583416","0.635492","0.6354457","0.6333575","0.63215905","0.63211644","0.6315798","0.63151157","0.63060665","0.6305438","0.63004017","0.6298623","0.6293224","0.62910473","0.6282657","0.62702596","0.6263622","0.6263223","0.6258792","0.6250831","0.62417686","0.6229321","0.6217813","0.61914027","0.61897147","0.6188083","0.6180896","0.6172952","0.6163544","0.6159313","0.61519706","0.6145711","0.61445695","0.6123396","0.61173576","0.611605","0.6104783","0.6103154","0.6098642","0.60880715"],"string":"[\n \"0.86339736\",\n \"0.8606109\",\n \"0.8603492\",\n \"0.85995936\",\n \"0.8557784\",\n \"0.8546807\",\n \"0.85401046\",\n \"0.8516957\",\n \"0.8511827\",\n \"0.84710205\",\n \"0.84403396\",\n \"0.8420791\",\n \"0.8380287\",\n \"0.8351859\",\n \"0.83487356\",\n \"0.8338624\",\n \"0.832877\",\n \"0.82504755\",\n \"0.824626\",\n \"0.8242384\",\n \"0.8223594\",\n \"0.79081684\",\n \"0.7731949\",\n \"0.7693404\",\n \"0.7634081\",\n \"0.74502015\",\n \"0.7342762\",\n \"0.71266776\",\n \"0.7049452\",\n \"0.69970644\",\n \"0.69469595\",\n \"0.687617\",\n \"0.68724865\",\n \"0.68673515\",\n \"0.6852626\",\n \"0.6849195\",\n \"0.683367\",\n \"0.6748739\",\n \"0.67290497\",\n \"0.6617615\",\n \"0.65847963\",\n \"0.6584383\",\n \"0.6578199\",\n \"0.65496385\",\n \"0.6546174\",\n \"0.6544184\",\n \"0.65305346\",\n \"0.65281457\",\n \"0.6494542\",\n \"0.6491491\",\n \"0.64771223\",\n \"0.6461849\",\n \"0.64503425\",\n \"0.64446306\",\n \"0.64446306\",\n \"0.6435211\",\n \"0.64304614\",\n \"0.6424253\",\n \"0.6399783\",\n \"0.6362248\",\n \"0.63583416\",\n \"0.635492\",\n \"0.6354457\",\n \"0.6333575\",\n \"0.63215905\",\n \"0.63211644\",\n \"0.6315798\",\n \"0.63151157\",\n \"0.63060665\",\n \"0.6305438\",\n \"0.63004017\",\n \"0.6298623\",\n \"0.6293224\",\n \"0.62910473\",\n \"0.6282657\",\n \"0.62702596\",\n \"0.6263622\",\n \"0.6263223\",\n \"0.6258792\",\n \"0.6250831\",\n \"0.62417686\",\n \"0.6229321\",\n \"0.6217813\",\n \"0.61914027\",\n \"0.61897147\",\n \"0.6188083\",\n \"0.6180896\",\n \"0.6172952\",\n \"0.6163544\",\n \"0.6159313\",\n \"0.61519706\",\n \"0.6145711\",\n \"0.61445695\",\n \"0.6123396\",\n \"0.61173576\",\n \"0.611605\",\n \"0.6104783\",\n \"0.6103154\",\n \"0.6098642\",\n \"0.60880715\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83550686"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":9496,"cells":{"query":{"kind":"string","value":"Method that returns the list of the JSON string representation json_string"},"document":{"kind":"string","value":"def from_json_string(json_string):\n if json_string is None or len(json_string) == 0:\n return []\n return json.loads(json_string)"},"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 from_json_string(json_string):\n lis = []\n # not sure if empty means empty string or len(jstr) < 1\n if json_string is None or json_string == \"\":\n return lis\n return json.loads(json_string)","def from_json_string(json_string):\n empty_list = []\n if json_string and json_string is not None:\n return json.loads(json_string)\n return empty_list","def from_json_string(json_string):\n new_list = []\n if json_string is None:\n return new_list\n else:\n return json.loads(json_string)","def from_json_string(json_string):\n\n the_list = []\n if json_string is not None and json_string != '':\n if type(json_string) != str:\n raise TypeError(\"json_string must be a string\")\n the_list = json.loads(json_string)\n return the_list","def from_json_string(json_string):\n\n l = []\n if json_string is None or len(json_string) <= 0:\n return l\n\n return json.loads(json_string)","def json(self):\n return [t.json for t in self.values()]","def from_json_string(json_string):\n empty_list = []\n if json_string is None:\n return empty_list\n else:\n return json.loads(json_string)","def _data_list(json: 'a json'):\n data = json['Time Series (Daily)']\n return list(data.items())","def str_to_list_json(s):\n s.replace(\"'\", '\"')\n return json.loads(s)","def from_json_string(json_string):\n if not json_string:\n return []\n return json.loads(json_string)","def jsons(self):\n if self._jsons is None:\n self.make_jsons()\n return self._jsons","def from_json_string(json_string):\n if json_string is None:\n return []\n return json.loads(json_string)","def from_json_string(json_string):\n if json_string is None or not json_string:\n return []\n return json.loads(json_string)","def __transform_list_to_jsons__(self, listofjsons):\n jsons = []\n for row in listofjsons:\n jsons += [json.dumps(row)]\n return jsons","def from_json_string(json_string):\n if json_string is None or json_string == \"\":\n return []\n else:\n return json.loads(json_string)","def from_json_string(json_string):\n if json_string is None or json_string == \"\":\n return []\n else:\n return json.loads(json_string)","def from_json_string(json_string):\n\n if json_string is None or json_string == '':\n return []\n else:\n return json.loads(json_string)","def json_taglist():\n tags = Tag.query.all()\n out = {'tags': []}\n for tag in tags:\n out['tags'].append(tag.value)\n\n return jsonify(out)","def json(self) -> List[Dict[str, Union[str, List[str]]]]:\n model_json: List[Dict[str, Union[str, List[str]]]] = []\n for phrase in self.phrase_index:\n entry = {'phrase': phrase}\n if phrase in self.has_variants:\n entry['variants'] = list(self.has_variants[phrase])\n if phrase in self.has_labels:\n entry['label'] = list(self.has_labels[phrase])\n if phrase in self.custom:\n entry['custom'] = self.custom[phrase]\n model_json += [entry]\n return model_json","def from_json_string(json_string):\n if json_string is None or len(json_string) == 0:\n return []\n else:\n return json.loads(json_string)","def get_json(self):\r\n self.get_recordrange()\r\n [\r\n self.json_data.setter(n, self.get_data(\"json\", x))\r\n for n, x in enumerate(tqdm(self.iterlist))\r\n ]","def retrieve_json(cls):\n objectjson = json.loads(jsondata)\n listimdata = objectjson['imdata']\n return listimdata","def sub_jsons(self, msg):\n i = 0\n result = []\n split_msg = msg.split('}{')\n for s in range(len(split_msg)):\n if i==0 and len(split_msg)==1:\n result.append(split_msg[s])\n elif i==0 and len(split_msg)>1:\n result.append(split_msg[s]+\"}\")\n elif i==len(split_msg)-1 and len(split_msg)>1:\n result.append(\"{\"+split_msg[s])\n else:\n result.append(\"{\"+split_msg[s]+\"}\")\n i+=1\n return result","def json(self):\n return self._parsejson(self.raw)","def from_json_string(json_string):\n if json_string is None or json_string == \"\":\n return ([])\n\n else:\n return (json.loads(json_string))","def list_from_json(json_string, klass):\n object_list = []\n dictionaries = json.loads(json_string)\n for dictionary in dictionaries:\n object_list.append(klass(**dictionary))\n return object_list","def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:","def parse_json(self, json_to_parse):\n json_obj = json.loads(json_to_parse)\n return_data = []\n for row in json_obj['data']:\n row_dict = {}\n for key, value in row.items():\n row_dict[key] = value\n return_data.append(row_dict)\n return return_data","def from_json_string(json_string):\n if json_string is None or len(json_string) == 0:\n return ([])\n return (json.loads(json_string))","def change_sets_into_lists(json_like: Any) -> Any:\r\n return json.loads(json.dumps(json_like, cls=SetEncoder))","def _parse_output(self, output):\n return [json.loads(x) for x in output]","def test_return_type(self):\n self.assertEqual(type(self.s0.from_json_string(self.string)), list)","def json(self):\n return json.loads(self.text)","def json(cls):\n\n nodes = []\n for node in cls._nodes:\n nodes.append(node.json())\n return nodes","def json_file_to_list(filename, config=None):\n with open(filename) as fp:\n return json.load(fp)","def field_to_json(field_list):\n def str_to_json(json_str):\n try:\n return json.loads(json_str)\n except:\n return None\n new_list = []\n for elem in field_list:\n json_obj = str_to_json(elem)\n if json_obj:\n new_list.append(json_obj)\n return new_list","def json(self):\n json_data = {}\n\n for item in self.iteritems():\n try:\n value = item.get_value(json_serializable=True)\n except TypeError:\n value = \"NOT_SERIALIZABLE\"\n item_data = {\n \"tags\": list(item.tags),\n \"value\": value,\n }\n if item.name in json_data:\n json_data[item.name].append(item_data)\n else:\n json_data[item.name] = [item_data]\n\n return json_data","def convert(self):\n if isinstance(self.json, list):\n return self.iter_list(self.json)\n\n if isinstance(self.json, dict):\n return self.iter_plain(self.json)\n\n return self.json","def _read_jsonl(cls, input_file):\n with open(input_file, \"r\", encoding=\"utf-8-sig\") as f:\n lines = []\n for line in f:\n lines.append(json.loads(line))\n return lines","def jsonify_list(data):\n assert data is not None\n indent = None\n if (current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] and\n not request.is_xhr):\n indent = 2\n data = dumps(data, indent=indent, sort_keys=False)\n\n mimetype = 'application/json; charset=utf-8'\n response = current_app.response_class(data, mimetype=mimetype)\n\n return response","def test_17_0_fromJsonString(self):\n\n list_input = [\n {'id': 89, 'width': 10, 'height': 4},\n {'id': 7, 'width': 1, 'height': 7}\n ]\n json_list_input = Rectangle.to_json_string(list_input)\n list_output = Rectangle.from_json_string(json_list_input)\n self.assertTrue(type(list_input), list)\n self.assertTrue(type(json_list_input), str)\n self.assertTrue(type(list_output), list)","def json(self):\n\n return json.loads(self.text)","def json_data(self):\n json_providers = getAdapters((self.context, self.request, self.view), IJSONDataProvider)\n results = []\n for name, provider in json_providers:\n results.append({'name': name or None,\n 'data': json.dumps(provider())})\n return results","def _order_json(self, json_string):\n\n if isinstance(json_string, dict):\n return sorted((k, self._order_json(v)) for k, v in json_string.items())\n if isinstance(json_string, list):\n return sorted(self._order_json(x) for x in json_string)\n else:\n return json_string","def json_data(self):\n return_data = []\n\n # Loop over num files\n for ifile in range(len(self.data)):\n\n # Loop over steps\n file_return_data = {}\n for istep in range(len(self.data[ifile])):\n file_return_data[istep] = {}\n for key in self.data[ifile][istep]:\n file_return_data[istep][key] = self.data[ifile][istep][key].tolist()\n\n return_data.append(file_return_data)\n\n return return_data","def get_json_data(file_path: str) -> list:\n with open(file_path, 'r') as file:\n return json.load(file)","def json(self):\n d = [err.json for err in self.errors]\n return d","def dict(self):\n\t\treturn self.json","def to_json(self):\n return serialize_list_by_id(self.id)","def get_data(data_type):\n json_list = list()\n for source in data_type.value:\n json_list += open_json_file(source)\n return json_list","def _load_json_list(dev_data, list_name):\n load_list = []\n json_list = dev_data.get(list_name, {}).get(\"value\")\n if json_list:\n try:\n load_list = json.loads(json_list)\n except (TypeError, ValueError):\n pass\n return load_list","def create_list(self, data):\n\n temp = []\n for item in data:\n if len(item) > 2:\n i = 0\n while i < len(item):\n temp.append(item[i:min(i+2, len(item))])\n i += 2\n else:\n temp.append(item)\n data = temp\n\n temp = []\n for item in data:\n if item[-1] == \"{\":\n temp.append(\"[\" + item[0][:-1] + \",\")\n elif item[-1] == \"}\":\n temp.append(\"],\")\n else:\n temp.append(\"[\" + \" \".join(item).replace(\":\", \",\") + \"],\")\n return ast.literal_eval(\"\".join(temp))","def json(self):\n return self._json","def convert_string_to_list(key, data, errors, context): # noqa\n value = data.get(key, None)\n\n if not value:\n return\n\n if not isinstance(value, basestring):\n return\n\n if not value.startswith('{') or not value.endswith('}'):\n return\n\n value = value.replace('\"', '')\n data[key] = value[1:len(value)-1].split(',')","def get_paste_list_json():\n with contextlib.closing(urllib2.urlopen(PASTE_SERVICE)) as text:\n return json.loads(text.read(), object_hook=Struct)","def json_friendly(self):","def read_json():\n with open(\"Ratings.json\") as json_data:\n json_list = []\n for line in json_data:\n json_dict = json.loads(line)\n json_list.append(json_dict)\n return json_list","def get_user_events_json_list(user_events):\n events = []\n for user_event in user_events:\n events.append(user_event.json())\n return events","def get_tags():\n\treturn jsonify(tags=[i.serialise for i in Tag.query.all()])","def test_list(self):\n jobj = JList(parent = 'some', keys = [])\n jdic = json.loads('[]')\n self.assertTrue(check_json_array(jdic, jobj))","def as_json(self):","def json(self):\n return self.__json","def json_statuslist():\n statuses = Status.query.all()\n out = {'statuses': []}\n for status in statuses:\n out['statuses'].append(status.value)\n\n return jsonify(out)","def jsonarray(json_array_string):\n\n temp_list = json.loads(json_array_string)\n hostlines = \"127.0.0.1 \" + \"\\n127.0.0.1 \".join(temp_list)\n return hostlines","def GetJSON(self):\n return json.dumps(self.GetDict())","def _read_jsonl(cls, input_file):\n with open(input_file, 'rb') as f:\n return [json.loads(ln) for ln in f]","def _read_jsonl(cls, input_file):\n with open(input_file, 'rb') as f:\n return [json.loads(ln) for ln in f]","def get_json_string(self, **kwargs):\n ...","def _cast_to_list(obj: JsonInput) -> JsonList:\n if isinstance(obj, list):\n return obj\n elif isinstance(obj, dict):\n return [obj]\n else:\n raise ValueError(\"Object is not a list of dict\")","def test_from_json_string(self):\n string = '[{\"id\": 4, \"width\": 3, \"height\": 4, \"x\": 1, \"y\": 3}, \\\n {\"id\": 3, \"width\": 6, \"height\": 2, \"x\": 1, \"y\": 9}]'\n jsonized = Base.from_json_string(string)\n self.assertEqual(len(jsonized), 2)\n self.assertTrue(type(jsonized) is list)","def json(self) -> Union[dict, list, str, int, float]:\n raise NotImplementedError # pragma: no cover","def _ListValueMessageToJsonObject(self, message):\n return [self._ValueMessageToJsonObject(value)\n for value in message.values]","def json(self, data):\n import json\n data = json.dumps(data)\n return data","def extract_messages(self,msg_list):\n msgs = []\n for m in msg_list:\n msgs.append(json.loads(str(m)))\n return msgs","def _get_list(\n session: \"Session\", url_tail: str, params: Optional[Dict[str, Any]] = None\n) -> List[Any]:\n response = _get(session, url_tail, params)\n return list(response.json())","def _get_data_as_json(self, data):\n data = self._get_data_as_df(data)\n data = data.to_json(orient=\"records\")\n char_per_line = min(len(data), self.SAMPLES_PER_LINE_DEFAULT)\n return list(map(''.join, zip(*[iter(data)] * char_per_line)))","def parse_jsons(self):\n return super(VegaGraphScatter, self).parse_jsons()","def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n return(\"[]\")\n json_string = json.dumps(list_dictionaries)\n return(json_string)","def _to_list(self, file_str):\n data_list = file_str.split()\n return data_list","def list():\n trucks = Foodtruck.query.all()\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])","def format_json(the_list):\n result = \"{\"\n index = 0\n size = len(the_list)\n while index < size:\n result += format_json_key(the_list[index][0], the_list[index][1])\n if index != size - 1:\n result += \", \"\n index += 1\n result += \"}\"\n return result","def list_to_json(items):\n return json.dumps(to_dict_list(items))","def dataframe_to_list(df: pandas.DataFrame) -> list:\n return json.loads(df.to_json(orient=\"records\"))","def test_json_string(self):\n Base._Base__nb_objects = 0\n d1 = {\"id\": 9, \"width\": 5, \"height\": 9, \"x\": 7, \"y\": 8}\n d2 = {\"id\": 10, \"width\": 3, \"height\": 15, \"x\": 4, \"y\": 0}\n json_string = Base.to_json_string([d1, d2])\n self.assertTrue(type(json_string) is str)\n d = json.loads(json_string)\n self.assertEqual(d, [d1, d2])","def test_from_json_string(self):\n json_str = '[{\"id\": 9, \"width\": 5, \"height\": 9, \"x\": 7, \"y\": 8}, \\\n {\"id\": 10, \"width\": 3, \"height\": 15, \"x\": 4, \"y\": 0}]'\n jason_list = Base.from_json_string(json_str)\n self.assertTrue(type(jason_list) is list)\n self.assertEqual(len(jason_list), 2)\n self.assertTrue(type(jason_list[0]) is dict)\n self.assertTrue(type(jason_list[1]) is dict)\n self.assertEqual(jason_list[0],\n {\"id\": 9, \"width\": 5, \"height\": 9, \"x\": 7, \"y\": 8})\n self.assertEqual(jason_list[1],\n {\"id\": 10, \"width\": 3, \"height\": 15, \"x\": 4, \"y\": 0})","def json(self, **kwargs):\n return json.loads(self.content, **kwargs)","def _read_jsonl(self, input_file, quotechar=None):\n with open(input_file, 'r', encoding='utf-8') as json_file:\n #line = list(json_file)[2]\n lines = []\n for line in json_file:\n json_text = json.loads(line)\n #reader = csv.reader(f, delimiter=\"\\t\", quotechar=quotechar)\n lines.append(json_text)\n return lines","def serialize_list(data):\n new_data = []\n for value in data:\n if isinstance(value, list):\n new_data.append(serialize_list(value))\n elif isinstance(value, dict):\n new_data.append(serialize_dict(value))\n elif isinstance(value, int) or isinstance(value, float) or isinstance(value, str) or isinstance(value, bool):\n new_data.append(value)\n else:\n return []\n\n return new_data","def test_listf(self):\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\n jdic = json.loads('[]')\n self.assertFalse(check_json_array(jdic, jobj))","def _convert_json_item_signature(item: Any) -> List[str]:\n if isinstance(item, list): # Cart list of dicts\n for j in item:\n return [str(k) for k in j.values()]\n elif item is True:\n return ['true']\n elif item is False:\n return ['false']\n\n return [str(item)]","def test_list_2(self):\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\n jdic = json.loads('[{\"test1\":3, \"test2\":4}]')\n self.assertTrue(check_json_array(jdic, jobj))","def json_load(text):\n if OLD_SUGAR_SYSTEM is True:\n _listdata = json.read(text)\n else:\n # strip out leading and trailing whitespace, nulls, and newlines\n text = text.lstrip()\n text = text.replace('\\12', '')\n text = text.replace('\\00', '')\n _io = StringIO(text.rstrip())\n _listdata = jload(_io)\n # json converts tuples to lists, so we need to convert back,\n return _tuplify(_listdata)","def toJSON(self):\r\n\r\n jsonToRet = []\r\n rowJson = []\r\n matrixJson = []\r\n\r\n if len(self.slctData) > 100:\r\n self.getSimMatSummary(100)\r\n jsonToRet.append(self.summaryOrdering)\r\n for i in range(0,len(self.simMatSmm)):\r\n for n in self.simMatSmm[i]:\r\n rowJson.append(n)\r\n matrixJson.append(rowJson)\r\n rowJson = []\r\n jsonToRet.append(matrixJson)\r\n\r\n jsonToRet.append(self.patchOrdering)\r\n # jsonToRet = []\r\n rowJson = []\r\n matrixJson = []\r\n\r\n for i in range(0,len(self.simMat)):\r\n for n in self.simMat[i]:\r\n rowJson.append(n)\r\n matrixJson.append(rowJson)\r\n rowJson = []\r\n jsonToRet.append(matrixJson)\r\n return jsonToRet","def _get_empty_json_object() -> List[Dict[str, Any]]:\n return [History._get_empty_session_object()]","def getaslist(self):\n l = []\n l.append(self.title.strip().encode('utf-8'))\n l.append(self.desc.strip().encode('utf-8'));\n l.append(self.course_number.strip().encode('utf-8'))\n l.append(self.duration.strip().encode('utf-8'))\n l.append(self.difficulty.strip().encode('utf-8'))\n l.append(self.instructors.strip().encode('utf-8'))\n l.append(self.url.strip().encode('utf-8'))\n return l","def _convertJsonToTupleOfList(self,payloadString):\n dirList = json.loads(payloadString)\n ## market cap information\n market_cap = []\n timeStamp = []\n\n for item in dirList:\n _ = str(item[\"date\"]).split(\"-\")\n year = _[0]\n month = _[1].lstrip('0')\n date = _[2].lstrip('0')\n\n cap_date = datetime.datetime(int(year), int(month), int(date))\n\n timeStamp.append(cap_date)\n market_cap.append(float(item[\"v1\"]))\n\n return (tuple(timeStamp),tuple(market_cap))","def json_loads(s):\n return json.loads(s, cls=DataDecoder)","def get(self):\n generos = Genero.recuperar_todos_los_generos()\n lista_generos = []\n for genero in generos:\n lista_generos.append(genero.obtener_json())\n return lista_generos"],"string":"[\n \"def from_json_string(json_string):\\n lis = []\\n # not sure if empty means empty string or len(jstr) < 1\\n if json_string is None or json_string == \\\"\\\":\\n return lis\\n return json.loads(json_string)\",\n \"def from_json_string(json_string):\\n empty_list = []\\n if json_string and json_string is not None:\\n return json.loads(json_string)\\n return empty_list\",\n \"def from_json_string(json_string):\\n new_list = []\\n if json_string is None:\\n return new_list\\n else:\\n return json.loads(json_string)\",\n \"def from_json_string(json_string):\\n\\n the_list = []\\n if json_string is not None and json_string != '':\\n if type(json_string) != str:\\n raise TypeError(\\\"json_string must be a string\\\")\\n the_list = json.loads(json_string)\\n return the_list\",\n \"def from_json_string(json_string):\\n\\n l = []\\n if json_string is None or len(json_string) <= 0:\\n return l\\n\\n return json.loads(json_string)\",\n \"def json(self):\\n return [t.json for t in self.values()]\",\n \"def from_json_string(json_string):\\n empty_list = []\\n if json_string is None:\\n return empty_list\\n else:\\n return json.loads(json_string)\",\n \"def _data_list(json: 'a json'):\\n data = json['Time Series (Daily)']\\n return list(data.items())\",\n \"def str_to_list_json(s):\\n s.replace(\\\"'\\\", '\\\"')\\n return json.loads(s)\",\n \"def from_json_string(json_string):\\n if not json_string:\\n return []\\n return json.loads(json_string)\",\n \"def jsons(self):\\n if self._jsons is None:\\n self.make_jsons()\\n return self._jsons\",\n \"def from_json_string(json_string):\\n if json_string is None:\\n return []\\n return json.loads(json_string)\",\n \"def from_json_string(json_string):\\n if json_string is None or not json_string:\\n return []\\n return json.loads(json_string)\",\n \"def __transform_list_to_jsons__(self, listofjsons):\\n jsons = []\\n for row in listofjsons:\\n jsons += [json.dumps(row)]\\n return jsons\",\n \"def from_json_string(json_string):\\n if json_string is None or json_string == \\\"\\\":\\n return []\\n else:\\n return json.loads(json_string)\",\n \"def from_json_string(json_string):\\n if json_string is None or json_string == \\\"\\\":\\n return []\\n else:\\n return json.loads(json_string)\",\n \"def from_json_string(json_string):\\n\\n if json_string is None or json_string == '':\\n return []\\n else:\\n return json.loads(json_string)\",\n \"def json_taglist():\\n tags = Tag.query.all()\\n out = {'tags': []}\\n for tag in tags:\\n out['tags'].append(tag.value)\\n\\n return jsonify(out)\",\n \"def json(self) -> List[Dict[str, Union[str, List[str]]]]:\\n model_json: List[Dict[str, Union[str, List[str]]]] = []\\n for phrase in self.phrase_index:\\n entry = {'phrase': phrase}\\n if phrase in self.has_variants:\\n entry['variants'] = list(self.has_variants[phrase])\\n if phrase in self.has_labels:\\n entry['label'] = list(self.has_labels[phrase])\\n if phrase in self.custom:\\n entry['custom'] = self.custom[phrase]\\n model_json += [entry]\\n return model_json\",\n \"def from_json_string(json_string):\\n if json_string is None or len(json_string) == 0:\\n return []\\n else:\\n return json.loads(json_string)\",\n \"def get_json(self):\\r\\n self.get_recordrange()\\r\\n [\\r\\n self.json_data.setter(n, self.get_data(\\\"json\\\", x))\\r\\n for n, x in enumerate(tqdm(self.iterlist))\\r\\n ]\",\n \"def retrieve_json(cls):\\n objectjson = json.loads(jsondata)\\n listimdata = objectjson['imdata']\\n return listimdata\",\n \"def sub_jsons(self, msg):\\n i = 0\\n result = []\\n split_msg = msg.split('}{')\\n for s in range(len(split_msg)):\\n if i==0 and len(split_msg)==1:\\n result.append(split_msg[s])\\n elif i==0 and len(split_msg)>1:\\n result.append(split_msg[s]+\\\"}\\\")\\n elif i==len(split_msg)-1 and len(split_msg)>1:\\n result.append(\\\"{\\\"+split_msg[s])\\n else:\\n result.append(\\\"{\\\"+split_msg[s]+\\\"}\\\")\\n i+=1\\n return result\",\n \"def json(self):\\n return self._parsejson(self.raw)\",\n \"def from_json_string(json_string):\\n if json_string is None or json_string == \\\"\\\":\\n return ([])\\n\\n else:\\n return (json.loads(json_string))\",\n \"def list_from_json(json_string, klass):\\n object_list = []\\n dictionaries = json.loads(json_string)\\n for dictionary in dictionaries:\\n object_list.append(klass(**dictionary))\\n return object_list\",\n \"def json(self) -> Dict[str, Union[List, Dict, str, int, float]]:\",\n \"def parse_json(self, json_to_parse):\\n json_obj = json.loads(json_to_parse)\\n return_data = []\\n for row in json_obj['data']:\\n row_dict = {}\\n for key, value in row.items():\\n row_dict[key] = value\\n return_data.append(row_dict)\\n return return_data\",\n \"def from_json_string(json_string):\\n if json_string is None or len(json_string) == 0:\\n return ([])\\n return (json.loads(json_string))\",\n \"def change_sets_into_lists(json_like: Any) -> Any:\\r\\n return json.loads(json.dumps(json_like, cls=SetEncoder))\",\n \"def _parse_output(self, output):\\n return [json.loads(x) for x in output]\",\n \"def test_return_type(self):\\n self.assertEqual(type(self.s0.from_json_string(self.string)), list)\",\n \"def json(self):\\n return json.loads(self.text)\",\n \"def json(cls):\\n\\n nodes = []\\n for node in cls._nodes:\\n nodes.append(node.json())\\n return nodes\",\n \"def json_file_to_list(filename, config=None):\\n with open(filename) as fp:\\n return json.load(fp)\",\n \"def field_to_json(field_list):\\n def str_to_json(json_str):\\n try:\\n return json.loads(json_str)\\n except:\\n return None\\n new_list = []\\n for elem in field_list:\\n json_obj = str_to_json(elem)\\n if json_obj:\\n new_list.append(json_obj)\\n return new_list\",\n \"def json(self):\\n json_data = {}\\n\\n for item in self.iteritems():\\n try:\\n value = item.get_value(json_serializable=True)\\n except TypeError:\\n value = \\\"NOT_SERIALIZABLE\\\"\\n item_data = {\\n \\\"tags\\\": list(item.tags),\\n \\\"value\\\": value,\\n }\\n if item.name in json_data:\\n json_data[item.name].append(item_data)\\n else:\\n json_data[item.name] = [item_data]\\n\\n return json_data\",\n \"def convert(self):\\n if isinstance(self.json, list):\\n return self.iter_list(self.json)\\n\\n if isinstance(self.json, dict):\\n return self.iter_plain(self.json)\\n\\n return self.json\",\n \"def _read_jsonl(cls, input_file):\\n with open(input_file, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as f:\\n lines = []\\n for line in f:\\n lines.append(json.loads(line))\\n return lines\",\n \"def jsonify_list(data):\\n assert data is not None\\n indent = None\\n if (current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] and\\n not request.is_xhr):\\n indent = 2\\n data = dumps(data, indent=indent, sort_keys=False)\\n\\n mimetype = 'application/json; charset=utf-8'\\n response = current_app.response_class(data, mimetype=mimetype)\\n\\n return response\",\n \"def test_17_0_fromJsonString(self):\\n\\n list_input = [\\n {'id': 89, 'width': 10, 'height': 4},\\n {'id': 7, 'width': 1, 'height': 7}\\n ]\\n json_list_input = Rectangle.to_json_string(list_input)\\n list_output = Rectangle.from_json_string(json_list_input)\\n self.assertTrue(type(list_input), list)\\n self.assertTrue(type(json_list_input), str)\\n self.assertTrue(type(list_output), list)\",\n \"def json(self):\\n\\n return json.loads(self.text)\",\n \"def json_data(self):\\n json_providers = getAdapters((self.context, self.request, self.view), IJSONDataProvider)\\n results = []\\n for name, provider in json_providers:\\n results.append({'name': name or None,\\n 'data': json.dumps(provider())})\\n return results\",\n \"def _order_json(self, json_string):\\n\\n if isinstance(json_string, dict):\\n return sorted((k, self._order_json(v)) for k, v in json_string.items())\\n if isinstance(json_string, list):\\n return sorted(self._order_json(x) for x in json_string)\\n else:\\n return json_string\",\n \"def json_data(self):\\n return_data = []\\n\\n # Loop over num files\\n for ifile in range(len(self.data)):\\n\\n # Loop over steps\\n file_return_data = {}\\n for istep in range(len(self.data[ifile])):\\n file_return_data[istep] = {}\\n for key in self.data[ifile][istep]:\\n file_return_data[istep][key] = self.data[ifile][istep][key].tolist()\\n\\n return_data.append(file_return_data)\\n\\n return return_data\",\n \"def get_json_data(file_path: str) -> list:\\n with open(file_path, 'r') as file:\\n return json.load(file)\",\n \"def json(self):\\n d = [err.json for err in self.errors]\\n return d\",\n \"def dict(self):\\n\\t\\treturn self.json\",\n \"def to_json(self):\\n return serialize_list_by_id(self.id)\",\n \"def get_data(data_type):\\n json_list = list()\\n for source in data_type.value:\\n json_list += open_json_file(source)\\n return json_list\",\n \"def _load_json_list(dev_data, list_name):\\n load_list = []\\n json_list = dev_data.get(list_name, {}).get(\\\"value\\\")\\n if json_list:\\n try:\\n load_list = json.loads(json_list)\\n except (TypeError, ValueError):\\n pass\\n return load_list\",\n \"def create_list(self, data):\\n\\n temp = []\\n for item in data:\\n if len(item) > 2:\\n i = 0\\n while i < len(item):\\n temp.append(item[i:min(i+2, len(item))])\\n i += 2\\n else:\\n temp.append(item)\\n data = temp\\n\\n temp = []\\n for item in data:\\n if item[-1] == \\\"{\\\":\\n temp.append(\\\"[\\\" + item[0][:-1] + \\\",\\\")\\n elif item[-1] == \\\"}\\\":\\n temp.append(\\\"],\\\")\\n else:\\n temp.append(\\\"[\\\" + \\\" \\\".join(item).replace(\\\":\\\", \\\",\\\") + \\\"],\\\")\\n return ast.literal_eval(\\\"\\\".join(temp))\",\n \"def json(self):\\n return self._json\",\n \"def convert_string_to_list(key, data, errors, context): # noqa\\n value = data.get(key, None)\\n\\n if not value:\\n return\\n\\n if not isinstance(value, basestring):\\n return\\n\\n if not value.startswith('{') or not value.endswith('}'):\\n return\\n\\n value = value.replace('\\\"', '')\\n data[key] = value[1:len(value)-1].split(',')\",\n \"def get_paste_list_json():\\n with contextlib.closing(urllib2.urlopen(PASTE_SERVICE)) as text:\\n return json.loads(text.read(), object_hook=Struct)\",\n \"def json_friendly(self):\",\n \"def read_json():\\n with open(\\\"Ratings.json\\\") as json_data:\\n json_list = []\\n for line in json_data:\\n json_dict = json.loads(line)\\n json_list.append(json_dict)\\n return json_list\",\n \"def get_user_events_json_list(user_events):\\n events = []\\n for user_event in user_events:\\n events.append(user_event.json())\\n return events\",\n \"def get_tags():\\n\\treturn jsonify(tags=[i.serialise for i in Tag.query.all()])\",\n \"def test_list(self):\\n jobj = JList(parent = 'some', keys = [])\\n jdic = json.loads('[]')\\n self.assertTrue(check_json_array(jdic, jobj))\",\n \"def as_json(self):\",\n \"def json(self):\\n return self.__json\",\n \"def json_statuslist():\\n statuses = Status.query.all()\\n out = {'statuses': []}\\n for status in statuses:\\n out['statuses'].append(status.value)\\n\\n return jsonify(out)\",\n \"def jsonarray(json_array_string):\\n\\n temp_list = json.loads(json_array_string)\\n hostlines = \\\"127.0.0.1 \\\" + \\\"\\\\n127.0.0.1 \\\".join(temp_list)\\n return hostlines\",\n \"def GetJSON(self):\\n return json.dumps(self.GetDict())\",\n \"def _read_jsonl(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return [json.loads(ln) for ln in f]\",\n \"def _read_jsonl(cls, input_file):\\n with open(input_file, 'rb') as f:\\n return [json.loads(ln) for ln in f]\",\n \"def get_json_string(self, **kwargs):\\n ...\",\n \"def _cast_to_list(obj: JsonInput) -> JsonList:\\n if isinstance(obj, list):\\n return obj\\n elif isinstance(obj, dict):\\n return [obj]\\n else:\\n raise ValueError(\\\"Object is not a list of dict\\\")\",\n \"def test_from_json_string(self):\\n string = '[{\\\"id\\\": 4, \\\"width\\\": 3, \\\"height\\\": 4, \\\"x\\\": 1, \\\"y\\\": 3}, \\\\\\n {\\\"id\\\": 3, \\\"width\\\": 6, \\\"height\\\": 2, \\\"x\\\": 1, \\\"y\\\": 9}]'\\n jsonized = Base.from_json_string(string)\\n self.assertEqual(len(jsonized), 2)\\n self.assertTrue(type(jsonized) is list)\",\n \"def json(self) -> Union[dict, list, str, int, float]:\\n raise NotImplementedError # pragma: no cover\",\n \"def _ListValueMessageToJsonObject(self, message):\\n return [self._ValueMessageToJsonObject(value)\\n for value in message.values]\",\n \"def json(self, data):\\n import json\\n data = json.dumps(data)\\n return data\",\n \"def extract_messages(self,msg_list):\\n msgs = []\\n for m in msg_list:\\n msgs.append(json.loads(str(m)))\\n return msgs\",\n \"def _get_list(\\n session: \\\"Session\\\", url_tail: str, params: Optional[Dict[str, Any]] = None\\n) -> List[Any]:\\n response = _get(session, url_tail, params)\\n return list(response.json())\",\n \"def _get_data_as_json(self, data):\\n data = self._get_data_as_df(data)\\n data = data.to_json(orient=\\\"records\\\")\\n char_per_line = min(len(data), self.SAMPLES_PER_LINE_DEFAULT)\\n return list(map(''.join, zip(*[iter(data)] * char_per_line)))\",\n \"def parse_jsons(self):\\n return super(VegaGraphScatter, self).parse_jsons()\",\n \"def to_json_string(list_dictionaries):\\n if list_dictionaries is None:\\n return(\\\"[]\\\")\\n json_string = json.dumps(list_dictionaries)\\n return(json_string)\",\n \"def _to_list(self, file_str):\\n data_list = file_str.split()\\n return data_list\",\n \"def list():\\n trucks = Foodtruck.query.all()\\n return jsonify(foodtrucks=[truck.to_dict() for truck in trucks])\",\n \"def format_json(the_list):\\n result = \\\"{\\\"\\n index = 0\\n size = len(the_list)\\n while index < size:\\n result += format_json_key(the_list[index][0], the_list[index][1])\\n if index != size - 1:\\n result += \\\", \\\"\\n index += 1\\n result += \\\"}\\\"\\n return result\",\n \"def list_to_json(items):\\n return json.dumps(to_dict_list(items))\",\n \"def dataframe_to_list(df: pandas.DataFrame) -> list:\\n return json.loads(df.to_json(orient=\\\"records\\\"))\",\n \"def test_json_string(self):\\n Base._Base__nb_objects = 0\\n d1 = {\\\"id\\\": 9, \\\"width\\\": 5, \\\"height\\\": 9, \\\"x\\\": 7, \\\"y\\\": 8}\\n d2 = {\\\"id\\\": 10, \\\"width\\\": 3, \\\"height\\\": 15, \\\"x\\\": 4, \\\"y\\\": 0}\\n json_string = Base.to_json_string([d1, d2])\\n self.assertTrue(type(json_string) is str)\\n d = json.loads(json_string)\\n self.assertEqual(d, [d1, d2])\",\n \"def test_from_json_string(self):\\n json_str = '[{\\\"id\\\": 9, \\\"width\\\": 5, \\\"height\\\": 9, \\\"x\\\": 7, \\\"y\\\": 8}, \\\\\\n {\\\"id\\\": 10, \\\"width\\\": 3, \\\"height\\\": 15, \\\"x\\\": 4, \\\"y\\\": 0}]'\\n jason_list = Base.from_json_string(json_str)\\n self.assertTrue(type(jason_list) is list)\\n self.assertEqual(len(jason_list), 2)\\n self.assertTrue(type(jason_list[0]) is dict)\\n self.assertTrue(type(jason_list[1]) is dict)\\n self.assertEqual(jason_list[0],\\n {\\\"id\\\": 9, \\\"width\\\": 5, \\\"height\\\": 9, \\\"x\\\": 7, \\\"y\\\": 8})\\n self.assertEqual(jason_list[1],\\n {\\\"id\\\": 10, \\\"width\\\": 3, \\\"height\\\": 15, \\\"x\\\": 4, \\\"y\\\": 0})\",\n \"def json(self, **kwargs):\\n return json.loads(self.content, **kwargs)\",\n \"def _read_jsonl(self, input_file, quotechar=None):\\n with open(input_file, 'r', encoding='utf-8') as json_file:\\n #line = list(json_file)[2]\\n lines = []\\n for line in json_file:\\n json_text = json.loads(line)\\n #reader = csv.reader(f, delimiter=\\\"\\\\t\\\", quotechar=quotechar)\\n lines.append(json_text)\\n return lines\",\n \"def serialize_list(data):\\n new_data = []\\n for value in data:\\n if isinstance(value, list):\\n new_data.append(serialize_list(value))\\n elif isinstance(value, dict):\\n new_data.append(serialize_dict(value))\\n elif isinstance(value, int) or isinstance(value, float) or isinstance(value, str) or isinstance(value, bool):\\n new_data.append(value)\\n else:\\n return []\\n\\n return new_data\",\n \"def test_listf(self):\\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\\n jdic = json.loads('[]')\\n self.assertFalse(check_json_array(jdic, jobj))\",\n \"def _convert_json_item_signature(item: Any) -> List[str]:\\n if isinstance(item, list): # Cart list of dicts\\n for j in item:\\n return [str(k) for k in j.values()]\\n elif item is True:\\n return ['true']\\n elif item is False:\\n return ['false']\\n\\n return [str(item)]\",\n \"def test_list_2(self):\\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\\n jdic = json.loads('[{\\\"test1\\\":3, \\\"test2\\\":4}]')\\n self.assertTrue(check_json_array(jdic, jobj))\",\n \"def json_load(text):\\n if OLD_SUGAR_SYSTEM is True:\\n _listdata = json.read(text)\\n else:\\n # strip out leading and trailing whitespace, nulls, and newlines\\n text = text.lstrip()\\n text = text.replace('\\\\12', '')\\n text = text.replace('\\\\00', '')\\n _io = StringIO(text.rstrip())\\n _listdata = jload(_io)\\n # json converts tuples to lists, so we need to convert back,\\n return _tuplify(_listdata)\",\n \"def toJSON(self):\\r\\n\\r\\n jsonToRet = []\\r\\n rowJson = []\\r\\n matrixJson = []\\r\\n\\r\\n if len(self.slctData) > 100:\\r\\n self.getSimMatSummary(100)\\r\\n jsonToRet.append(self.summaryOrdering)\\r\\n for i in range(0,len(self.simMatSmm)):\\r\\n for n in self.simMatSmm[i]:\\r\\n rowJson.append(n)\\r\\n matrixJson.append(rowJson)\\r\\n rowJson = []\\r\\n jsonToRet.append(matrixJson)\\r\\n\\r\\n jsonToRet.append(self.patchOrdering)\\r\\n # jsonToRet = []\\r\\n rowJson = []\\r\\n matrixJson = []\\r\\n\\r\\n for i in range(0,len(self.simMat)):\\r\\n for n in self.simMat[i]:\\r\\n rowJson.append(n)\\r\\n matrixJson.append(rowJson)\\r\\n rowJson = []\\r\\n jsonToRet.append(matrixJson)\\r\\n return jsonToRet\",\n \"def _get_empty_json_object() -> List[Dict[str, Any]]:\\n return [History._get_empty_session_object()]\",\n \"def getaslist(self):\\n l = []\\n l.append(self.title.strip().encode('utf-8'))\\n l.append(self.desc.strip().encode('utf-8'));\\n l.append(self.course_number.strip().encode('utf-8'))\\n l.append(self.duration.strip().encode('utf-8'))\\n l.append(self.difficulty.strip().encode('utf-8'))\\n l.append(self.instructors.strip().encode('utf-8'))\\n l.append(self.url.strip().encode('utf-8'))\\n return l\",\n \"def _convertJsonToTupleOfList(self,payloadString):\\n dirList = json.loads(payloadString)\\n ## market cap information\\n market_cap = []\\n timeStamp = []\\n\\n for item in dirList:\\n _ = str(item[\\\"date\\\"]).split(\\\"-\\\")\\n year = _[0]\\n month = _[1].lstrip('0')\\n date = _[2].lstrip('0')\\n\\n cap_date = datetime.datetime(int(year), int(month), int(date))\\n\\n timeStamp.append(cap_date)\\n market_cap.append(float(item[\\\"v1\\\"]))\\n\\n return (tuple(timeStamp),tuple(market_cap))\",\n \"def json_loads(s):\\n return json.loads(s, cls=DataDecoder)\",\n \"def get(self):\\n generos = Genero.recuperar_todos_los_generos()\\n lista_generos = []\\n for genero in generos:\\n lista_generos.append(genero.obtener_json())\\n return lista_generos\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7202782","0.71640325","0.71429116","0.7090925","0.70497406","0.70338446","0.6975703","0.68670994","0.6847883","0.6829183","0.6806034","0.6722226","0.66883564","0.6621443","0.66010094","0.66010094","0.6556371","0.6529802","0.648166","0.64465785","0.6331285","0.6293084","0.6263675","0.6242742","0.6221994","0.62087435","0.6185669","0.6143401","0.6140419","0.6064879","0.6047071","0.6037412","0.6026203","0.6007997","0.59550357","0.5952538","0.5950539","0.5950213","0.59468365","0.5934536","0.59255075","0.59219676","0.59105384","0.58990866","0.58776796","0.58504903","0.5850354","0.5839747","0.5831813","0.5809288","0.580664","0.57934546","0.5780436","0.57700247","0.57615006","0.5747106","0.5743787","0.5713307","0.57091475","0.567952","0.5669335","0.5666376","0.56626064","0.5659783","0.5658932","0.56355065","0.56355065","0.56261915","0.56227666","0.56109494","0.5599372","0.55970615","0.5596621","0.5595708","0.55898076","0.5584584","0.5572329","0.5569032","0.555529","0.5551983","0.5549394","0.5547279","0.554528","0.5544857","0.5539208","0.5534679","0.5532413","0.5531582","0.5523541","0.5517243","0.55126125","0.5506637","0.5485588","0.5485525","0.54851544","0.5483689","0.5463985","0.5447379"],"string":"[\n \"0.7202782\",\n \"0.71640325\",\n \"0.71429116\",\n \"0.7090925\",\n \"0.70497406\",\n \"0.70338446\",\n \"0.6975703\",\n \"0.68670994\",\n \"0.6847883\",\n \"0.6829183\",\n \"0.6806034\",\n \"0.6722226\",\n \"0.66883564\",\n \"0.6621443\",\n \"0.66010094\",\n \"0.66010094\",\n \"0.6556371\",\n \"0.6529802\",\n \"0.648166\",\n \"0.64465785\",\n \"0.6331285\",\n \"0.6293084\",\n \"0.6263675\",\n \"0.6242742\",\n \"0.6221994\",\n \"0.62087435\",\n \"0.6185669\",\n \"0.6143401\",\n \"0.6140419\",\n \"0.6064879\",\n \"0.6047071\",\n \"0.6037412\",\n \"0.6026203\",\n \"0.6007997\",\n \"0.59550357\",\n \"0.5952538\",\n \"0.5950539\",\n \"0.5950213\",\n \"0.59468365\",\n \"0.5934536\",\n \"0.59255075\",\n \"0.59219676\",\n \"0.59105384\",\n \"0.58990866\",\n \"0.58776796\",\n \"0.58504903\",\n \"0.5850354\",\n \"0.5839747\",\n \"0.5831813\",\n \"0.5809288\",\n \"0.580664\",\n \"0.57934546\",\n \"0.5780436\",\n \"0.57700247\",\n \"0.57615006\",\n \"0.5747106\",\n \"0.5743787\",\n \"0.5713307\",\n \"0.57091475\",\n \"0.567952\",\n \"0.5669335\",\n \"0.5666376\",\n \"0.56626064\",\n \"0.5659783\",\n \"0.5658932\",\n \"0.56355065\",\n \"0.56355065\",\n \"0.56261915\",\n \"0.56227666\",\n \"0.56109494\",\n \"0.5599372\",\n \"0.55970615\",\n \"0.5596621\",\n \"0.5595708\",\n \"0.55898076\",\n \"0.5584584\",\n \"0.5572329\",\n \"0.5569032\",\n \"0.555529\",\n \"0.5551983\",\n \"0.5549394\",\n \"0.5547279\",\n \"0.554528\",\n \"0.5544857\",\n \"0.5539208\",\n \"0.5534679\",\n \"0.5532413\",\n \"0.5531582\",\n \"0.5523541\",\n \"0.5517243\",\n \"0.55126125\",\n \"0.5506637\",\n \"0.5485588\",\n \"0.5485525\",\n \"0.54851544\",\n \"0.5483689\",\n \"0.5463985\",\n \"0.5447379\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64909357"},"document_rank":{"kind":"string","value":"19"}}},{"rowIdx":9497,"cells":{"query":{"kind":"string","value":"Method that returns an instance with all attributes already set"},"document":{"kind":"string","value":"def create(cls, **dictionary):\n if cls.__name__ == \"Rectangle\":\n dummy = cls(1, 1)\n elif cls.__name__ == \"Square\":\n dummy = cls(1)\n dummy.update(**dictionary)\n return dummy"},"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 copy(self):\n def init(self, **kwargs):\n \"\"\"Initialization.\"\"\"\n for k, v in kwargs.items():\n setattr(self, k, v)\n\n return type(type(self).__name__, (type(self),), {\"__init__\": init})(**self.__dict__)","def make(cls, **kwargs):\r\n return cls().fill(**kwargs)","def copy(self):\n cls = self.__class__\n result = cls.__new__(cls)\n result.__dict__.update(self.__dict__)\n return result","def copy(self):\n return self.__class__(**vars(self))","def __init__(self, **attributes):\n self.set(**attributes)","def __init__(self, **kwargs):\n self.__dict__.update(kwargs)","def __init__(self, **kwargs):\n self.__dict__.update(kwargs)","def build(cls, **kwargs):\n new_object = cls()\n fields = get_fields(cls)\n fields = dict((field.field_name, field) for field in fields)\n for name, value in kwargs.items():\n object.__setattr__(new_object, name, value)\n \n return new_object","def __init__(self, attrs = None):\n\n if attrs != None:\n self.__dict__.update(attrs)","def copy(self):\n return self.__class__(dict(self))","def __init__( self, **kwargs ):\n self.__dict__.update( kwargs )","def _chain(self, **kwargs):\n obj = self._clone()\n obj.__dict__.update(kwargs)\n return obj","def _clone(self):\n #可见，这样可以将本类初始化参数全部赋给c对象，作为c的属性\n c = self.__class__(model=self.model, query=self.query.chain(), using=self._db, hints=self._hints)\n c._sticky_filter = self._sticky_filter\n c._for_write = self._for_write\n c._prefetch_related_lookups = self._prefetch_related_lookups[:]\n c._known_related_objects = self._known_related_objects\n c._iterable_class = self._iterable_class\n c._fields = self._fields\n return c","def init( self ):\n\t\treturn self","def __copy__(self):\n cls = self.__class__\n result = cls.__new__(cls)\n to_copy = {\"_cache\", \"_buffers\", \"_parameters\", \"_modules\"}\n result.__dict__.update(\n {k: v.copy() if k in to_copy else v for k, v in self.__dict__.items()}\n )\n return result","def copy(self):\n new = self.__class__(integration=None, data=None)\n for attribute, value in self.__dict__.items():\n if attribute in self.referenced_attributes:\n setattr(new, attribute, value)\n elif hasattr(value, 'copy'):\n setattr(new, attribute, value.copy())\n else:\n setattr(new, attribute, deepcopy(value))\n return new","def copy(self):\n new = object.__new__(type(self))\n new.approximate_online_count = self.approximate_online_count\n new.approximate_user_count = self.approximate_user_count\n new.description = self.description\n new.discovery_splash_hash = self.discovery_splash_hash\n new.discovery_splash_type = self.discovery_splash_type\n new.emojis = self.emojis.copy()\n features = self.features\n if (features is not None):\n features = (*features,)\n new.features = features\n new.icon_hash = self.icon_hash\n new.icon_type = self.icon_type\n new.id = self.id\n new.invite_splash_hash = self.invite_splash_hash\n new.invite_splash_type = self.invite_splash_type\n new.stickers = self.stickers.copy()\n new.name = self.name\n return new","def copy(self):\n return self.update({})","def clone(self, **kwargs):\n return attr.evolve(self, **kwargs)","def prepare(self):\n return self","def copy(self):\n return AttrDict(dict(self).copy())","def fill(self, **kwargs):\r\n for name in kwargs.keys():\r\n setattr(self, name, kwargs[name])\r\n return self","def build(cls, **kwargs):\n return cls(kwargs) #pylint: disable=no-value-for-parameter","def get(self) -> dict:\n return clone(vars(self))","def new(cls, **kwargs):\n return cls(**kwargs)","def make_instance(cls):\r\n def get_value(name):\r\n if name in attributes:\r\n return attributes[name]\r\n else:\r\n value = cls['get'](name)\r\n return bind_method(value, instance)\r\n\r\n def set_value(name, value):\r\n attributes[name] = value\r\n\r\n attributes = {}\r\n instance = {'get': get_value, 'set': set_value}\r\n return instance","def copy(self):\n new = object.__new__(type(self))\n new.required = self.required\n new.title = self.title\n new.type = self.type\n values = self.values\n if (values is not None):\n values = (*values,)\n new.values = values\n return new","def clone(self):\n return attr.evolve(self, env=dict(self._env))","def _clone(self):\n c = self.__class__(\n model=self.model,\n query=self.query.chain(),\n using=self._db,\n hints=self._hints,\n )\n c._sticky_filter = self._sticky_filter\n c._for_write = self._for_write\n c._prefetch_related_lookups = self._prefetch_related_lookups[:]\n c._known_related_objects = self._known_related_objects\n c._iterable_class = self._iterable_class\n c._fields = self._fields\n return c","def make_instance(self, data, **kwargs):\n instance = self.instance or self.get_instance(data)\n if instance is not None:\n for key, value in iteritems(data):\n setattr(instance, key, value)\n return instance\n kwargs, association_attrs = self._split_model_kwargs_association(data)\n instance = self.opts.model(**kwargs)\n for attr, value in iteritems(association_attrs):\n setattr(instance, attr, value)\n return instance","def copy(self):\n r = PredictionJobRequest()\n r.__dict__.update(self.__dict__)\n\n return r","def __init__(self, **attributes):\n for key, value in attributes.items():\n setattr(self, key, value)","def clone(self):\n return attr.evolve(self)","def new(self, **kwargs):\n return self.__model__(**self._preprocess_params(kwargs))","def __copy__(self):\n trait_data = self.__getstate__()\n inst = self.__class__.create(trait_data)\n return inst","def copy(self):\n new = object.__new__(type(self))\n new.avatar_hash = self.avatar_hash\n new.avatar_type = self.avatar_type\n new.boosts_since = self.boosts_since\n new.flags = self.flags\n new.joined_at = self.joined_at\n new.nick = self.nick\n new.pending = self.pending\n role_ids = self.role_ids\n if (role_ids is not None):\n role_ids = (*role_ids,)\n new.role_ids = role_ids\n new.timed_out_until = self.timed_out_until\n return new","def _chain(self, **kwargs):\n obj = self._clone()\n if obj._sticky_filter:\n obj.query.filter_is_sticky = True\n obj._sticky_filter = False\n obj.__dict__.update(kwargs)\n return obj","def __init__(self, **kwargs):\n assert self.__class__.get_primary() != None\n for field in self.fields()+self.tables():\n value = object.__getattribute__(self, field)\n instance = value.__class__(*value.args, **value.kwargs)\n instance.model = self\n object.__setattr__(self, field, instance)\n \n for key, val in kwargs.iteritems():\n self.__setattr__(key, val)\n \n self._retrieved = False","def clone(self, **attr):\n # important\n obj = copy.deepcopy(self)\n obj.__dict__.update(attr)\n return obj","def clone(self):\n return self.__class__(self.name, *self)","def copy(self):\n new = object.__new__(type(self))\n new.bot = self.bot\n new.description = self.description\n new.icon_hash = self.icon_hash\n new.icon_type = self.icon_type\n new.id = 0\n new.name = self.name\n return new","def modified(self, **attributes):\n new_obj = deepcopy(self)\n new_obj.__dict__.update(attributes)\n new_obj.initialize()\n return new_obj","def copy(self):\n cls = type(self)\n # Create a new instance without calling __init__: parameters are\n # different depending on the class.\n new_box = cls.__new__(cls)\n # Copy attributes\n new_box.__dict__.update(self.__dict__)\n return new_box","def __init__(self, **kw):\r\n self.__dict__.update(kw)","def __call__(cls, *args, **kwargs):\n obj = type.__call__(cls, *args, **kwargs)\n obj.initialize()\n return obj","def _get_all_attributes(self) -> Dict[str, Any]:\n all_attributes = self.__dict__.copy()\n all_attributes.update(self.class_attributes)\n return all_attributes","def clone(self):\n memo = dict()\n c = self._clone(memo)\n c._clone_rip(memo)\n return c","def __new__(mcs, name, bases, attrs, **kwargs):\r\n attrs['__fields__'] = set()\r\n attrs['__store_attrs__'] = set()\r\n return super().__new__(mcs, name, bases, attrs, **kwargs)","def _get_all_attributes(self):\n all_attributes = self.__dict__.copy()\n all_attributes.update(self.class_attributes)\n return all_attributes","def copy (self, **kwargs):\n out = copy.deepcopy (self)\n out.update (**kwargs)\n return out","def copy_with(self):\n return self.copy()","def copy(self):\r\n\t\tobj = DecaLink()\r\n\t\tfor k in self.__dict__.keys():\r\n\t\t\tobj.__setattr__(k, self.__getattribute__(k))\r\n\t\treturn obj","def copy(self):\n return self.from_dict(self.to_dict(True))","def _set_attributes(self):","def copy(self):\n out = type(self).__new__(self.__class__)\n out.__dict__.update(self.__dict__)\n # make sure the copy has its own unique random number generator\n seed_seq = self.rng._bit_generator._seed_seq.spawn(1)[0]\n out.__dict__['rng'] = get_generator(seed_seq)\n return out","def __call__(self, *args, **kwargs):\n if not self.instance:\n self.instance = super().__call__(*args, **kwargs)\n return self.instance","def clone(self) -> Any:\n clone = super().clone()\n clone.clear()\n return clone","def self(self):\n attributelist = [k for k in type(self).__dict__ if not k.startswith(\"_\")]\n return SelfWrapper(self, attributelist)","def new_object(cls):\n return cls.for_value([])","def make_empty(cls):\n args = inspect.getargspec(cls.__init__).args\n # remove self; always first arg of __init__\n args = args[1:]\n return cls(**dict.fromkeys(args))","def new_deconstruct(self):\n name, path, args, kwargs = original_deconstruct(self)\n for attr in IGNORED_ATTRS:\n kwargs.pop(attr, None)\n return name, path, args, kwargs","def clone(self):\n\n copy = self.__class__(self.name, self.data)\n\n copy.set_fixed_variables_from_pdf(self)\n \n return copy","def get(self) -> dict:\n return clone(self.__dict__)","def __init__(self, **kwargs):\n # loop over the given kwargs\n for key, value in kwargs.items():\n # treat them like attribute assignments\n setattr(self, key, value)","def __copy__(self, *args, **kwargs):\n return self.copy()","def __init__(self, **initial_attributes):\n\n for attribute_name, attribute_value in initial_attributes.items():\n setattr(self, attribute_name, attribute_value)","def __copy__(self):\n d = dict()\n d.update(self.items())\n return d","def __copy__(self):\n # prepare unnamed arguments\n args = [getattr(self, arg) for arg in self._copy_conf['args']]\n\n # prepare named arguments\n kwargs = {}\n for arg in self._copy_conf['kwargs']:\n # if arg is a tuple, the first entry will be the named kwargs, and\n # the second will be the name of the attribute to copy\n name = arg\n if isinstance(arg, tuple):\n name, arg = arg\n if hasattr(self, arg):\n kwargs[name] = getattr(self, arg)\n\n # create the new instance\n new_copy = self.__class__(*args, **kwargs)\n\n # then copy attributes\n for attr_name in self._copy_conf['attrs']:\n if hasattr(self, attr_name):\n setattr(new_copy, attr_name, getattr(self, attr_name))\n\n return new_copy","def copy(self) -> AF:\n if self._base == OrderedDict:\n kopied = dict(self)\n else:\n kopied = self._base.copy(self)\n return self.__class__(kopied, use_fuzzy=self.use_fuzzy, dottable=self._dottable)","def copy(self):\n new = self.__class__()\n new.values = self.values.copy()\n return new","def __call__(self):\n return self","def copy(self):\n\n obj = MixedLMParams(self.k_fe, self.k_re, self.use_sqrt)\n obj.set_packed(self.get_packed().copy())\n return obj","def __init__(self, *args, **kwargs):\n super(AttrDict, self).__init__(*args, **kwargs)\n self.__dict__ = self","def clone(self):\n return self","def clone(self):\r\n obj = CylinderModel()\r\n obj.params = copy.deepcopy(self.params)\r\n return obj","def rpConstruct(cls):\r\n return cls(None, None, None)","def copy(self):\n return self.__class__(self)","def copy(self):\n return self.__class__(self)","def __init__(self, **attrs):\n \n # set given attributes\n for name, value in attrs.items():\n if hasattr(self, name):\n setattr(self, name, value)\n else:\n raise AttributeError(\"Attribute not found! --> %s\" % name)","def copy(self):\n return self.from_builder(self)","def _chain(self):\n obj = self._clone()\n if obj._sticky_filter:\n obj.query.filter_is_sticky = True\n obj._sticky_filter = False\n return obj","def __new__(cls, *args, **kwargs):\n obj = super().__new__(cls)\n obj.init_kwargs = cls.init_params(*args, **kwargs)\n return obj","def get_pure_data_copy(self):\n import copy\n data=copy.copy(self)\n data.xp = data.xp.get_pure_data_copy()\n data.timetable = data.timetable.get_pure_data_copy() \n return data","def clone(self, *args, **kwargs):\n return self.copy().reset(*args, **kwargs)","def __copy__(self):\n return self.copy()","def __init__(self, **kwargs):\n for key, value in kwargs.items():\n setattr(self, key, value)","def _instantiate(cls, **kwargs):\n return cls(**kwargs)","def __enter__(self):\n self.__init__()\n return self","def __init__ (self, d):\n try:\n self.__dict__.update (d.__dict__)\n except:\n self.__dict__.update (d)","def copy(self):\n return self.__class__(self.items, self.is_cloud)","def copy(self):\n return self.__class__(*self.sets)","def copy(self, **kwargs):\n instance = copy(self)\n kwargs.update({\n 'id': None,\n 'pk': None,\n })\n instance.update_from_kwargs(**kwargs)\n return instance","def build(self):\n return ConnectionParams(self)","def clone_and_update(self, **kwargs):\n cloned = self.clone()\n cloned.update(**kwargs)\n return cloned","def copy(self):\r\n # This way of initializing the copy means it works for subclasses, too.\r\n obj = self.__class__(self)\r\n obj.keyOrder = self.keyOrder[:]\r\n return obj","def create(cls, **dictionary):\n dummy_obj = cls(1, 1)\n dummy_obj.update(**dictionary)\n return dummy_obj","def __init__(self, **kwargs):\n\t\tself.vars = kwargs\n\t\tself.old_vars = None","def __init__(self, **kwargs):\n for key, val in kwargs.items():\n setattr(self, key, val)","def __init__(self, **kwargs):\n for key, val in kwargs.items():\n setattr(self, key, val)","def __init__(self, **kwargs):\n for key, val in kwargs.items():\n setattr(self, key, val)","def __call__(self):\n return self.cls(**self.kwargs)"],"string":"[\n \"def copy(self):\\n def init(self, **kwargs):\\n \\\"\\\"\\\"Initialization.\\\"\\\"\\\"\\n for k, v in kwargs.items():\\n setattr(self, k, v)\\n\\n return type(type(self).__name__, (type(self),), {\\\"__init__\\\": init})(**self.__dict__)\",\n \"def make(cls, **kwargs):\\r\\n return cls().fill(**kwargs)\",\n \"def copy(self):\\n cls = self.__class__\\n result = cls.__new__(cls)\\n result.__dict__.update(self.__dict__)\\n return result\",\n \"def copy(self):\\n return self.__class__(**vars(self))\",\n \"def __init__(self, **attributes):\\n self.set(**attributes)\",\n \"def __init__(self, **kwargs):\\n self.__dict__.update(kwargs)\",\n \"def __init__(self, **kwargs):\\n self.__dict__.update(kwargs)\",\n \"def build(cls, **kwargs):\\n new_object = cls()\\n fields = get_fields(cls)\\n fields = dict((field.field_name, field) for field in fields)\\n for name, value in kwargs.items():\\n object.__setattr__(new_object, name, value)\\n \\n return new_object\",\n \"def __init__(self, attrs = None):\\n\\n if attrs != None:\\n self.__dict__.update(attrs)\",\n \"def copy(self):\\n return self.__class__(dict(self))\",\n \"def __init__( self, **kwargs ):\\n self.__dict__.update( kwargs )\",\n \"def _chain(self, **kwargs):\\n obj = self._clone()\\n obj.__dict__.update(kwargs)\\n return obj\",\n \"def _clone(self):\\n #可见，这样可以将本类初始化参数全部赋给c对象，作为c的属性\\n c = self.__class__(model=self.model, query=self.query.chain(), using=self._db, hints=self._hints)\\n c._sticky_filter = self._sticky_filter\\n c._for_write = self._for_write\\n c._prefetch_related_lookups = self._prefetch_related_lookups[:]\\n c._known_related_objects = self._known_related_objects\\n c._iterable_class = self._iterable_class\\n c._fields = self._fields\\n return c\",\n \"def init( self ):\\n\\t\\treturn self\",\n \"def __copy__(self):\\n cls = self.__class__\\n result = cls.__new__(cls)\\n to_copy = {\\\"_cache\\\", \\\"_buffers\\\", \\\"_parameters\\\", \\\"_modules\\\"}\\n result.__dict__.update(\\n {k: v.copy() if k in to_copy else v for k, v in self.__dict__.items()}\\n )\\n return result\",\n \"def copy(self):\\n new = self.__class__(integration=None, data=None)\\n for attribute, value in self.__dict__.items():\\n if attribute in self.referenced_attributes:\\n setattr(new, attribute, value)\\n elif hasattr(value, 'copy'):\\n setattr(new, attribute, value.copy())\\n else:\\n setattr(new, attribute, deepcopy(value))\\n return new\",\n \"def copy(self):\\n new = object.__new__(type(self))\\n new.approximate_online_count = self.approximate_online_count\\n new.approximate_user_count = self.approximate_user_count\\n new.description = self.description\\n new.discovery_splash_hash = self.discovery_splash_hash\\n new.discovery_splash_type = self.discovery_splash_type\\n new.emojis = self.emojis.copy()\\n features = self.features\\n if (features is not None):\\n features = (*features,)\\n new.features = features\\n new.icon_hash = self.icon_hash\\n new.icon_type = self.icon_type\\n new.id = self.id\\n new.invite_splash_hash = self.invite_splash_hash\\n new.invite_splash_type = self.invite_splash_type\\n new.stickers = self.stickers.copy()\\n new.name = self.name\\n return new\",\n \"def copy(self):\\n return self.update({})\",\n \"def clone(self, **kwargs):\\n return attr.evolve(self, **kwargs)\",\n \"def prepare(self):\\n return self\",\n \"def copy(self):\\n return AttrDict(dict(self).copy())\",\n \"def fill(self, **kwargs):\\r\\n for name in kwargs.keys():\\r\\n setattr(self, name, kwargs[name])\\r\\n return self\",\n \"def build(cls, **kwargs):\\n return cls(kwargs) #pylint: disable=no-value-for-parameter\",\n \"def get(self) -> dict:\\n return clone(vars(self))\",\n \"def new(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def make_instance(cls):\\r\\n def get_value(name):\\r\\n if name in attributes:\\r\\n return attributes[name]\\r\\n else:\\r\\n value = cls['get'](name)\\r\\n return bind_method(value, instance)\\r\\n\\r\\n def set_value(name, value):\\r\\n attributes[name] = value\\r\\n\\r\\n attributes = {}\\r\\n instance = {'get': get_value, 'set': set_value}\\r\\n return instance\",\n \"def copy(self):\\n new = object.__new__(type(self))\\n new.required = self.required\\n new.title = self.title\\n new.type = self.type\\n values = self.values\\n if (values is not None):\\n values = (*values,)\\n new.values = values\\n return new\",\n \"def clone(self):\\n return attr.evolve(self, env=dict(self._env))\",\n \"def _clone(self):\\n c = self.__class__(\\n model=self.model,\\n query=self.query.chain(),\\n using=self._db,\\n hints=self._hints,\\n )\\n c._sticky_filter = self._sticky_filter\\n c._for_write = self._for_write\\n c._prefetch_related_lookups = self._prefetch_related_lookups[:]\\n c._known_related_objects = self._known_related_objects\\n c._iterable_class = self._iterable_class\\n c._fields = self._fields\\n return c\",\n \"def make_instance(self, data, **kwargs):\\n instance = self.instance or self.get_instance(data)\\n if instance is not None:\\n for key, value in iteritems(data):\\n setattr(instance, key, value)\\n return instance\\n kwargs, association_attrs = self._split_model_kwargs_association(data)\\n instance = self.opts.model(**kwargs)\\n for attr, value in iteritems(association_attrs):\\n setattr(instance, attr, value)\\n return instance\",\n \"def copy(self):\\n r = PredictionJobRequest()\\n r.__dict__.update(self.__dict__)\\n\\n return r\",\n \"def __init__(self, **attributes):\\n for key, value in attributes.items():\\n setattr(self, key, value)\",\n \"def clone(self):\\n return attr.evolve(self)\",\n \"def new(self, **kwargs):\\n return self.__model__(**self._preprocess_params(kwargs))\",\n \"def __copy__(self):\\n trait_data = self.__getstate__()\\n inst = self.__class__.create(trait_data)\\n return inst\",\n \"def copy(self):\\n new = object.__new__(type(self))\\n new.avatar_hash = self.avatar_hash\\n new.avatar_type = self.avatar_type\\n new.boosts_since = self.boosts_since\\n new.flags = self.flags\\n new.joined_at = self.joined_at\\n new.nick = self.nick\\n new.pending = self.pending\\n role_ids = self.role_ids\\n if (role_ids is not None):\\n role_ids = (*role_ids,)\\n new.role_ids = role_ids\\n new.timed_out_until = self.timed_out_until\\n return new\",\n \"def _chain(self, **kwargs):\\n obj = self._clone()\\n if obj._sticky_filter:\\n obj.query.filter_is_sticky = True\\n obj._sticky_filter = False\\n obj.__dict__.update(kwargs)\\n return obj\",\n \"def __init__(self, **kwargs):\\n assert self.__class__.get_primary() != None\\n for field in self.fields()+self.tables():\\n value = object.__getattribute__(self, field)\\n instance = value.__class__(*value.args, **value.kwargs)\\n instance.model = self\\n object.__setattr__(self, field, instance)\\n \\n for key, val in kwargs.iteritems():\\n self.__setattr__(key, val)\\n \\n self._retrieved = False\",\n \"def clone(self, **attr):\\n # important\\n obj = copy.deepcopy(self)\\n obj.__dict__.update(attr)\\n return obj\",\n \"def clone(self):\\n return self.__class__(self.name, *self)\",\n \"def copy(self):\\n new = object.__new__(type(self))\\n new.bot = self.bot\\n new.description = self.description\\n new.icon_hash = self.icon_hash\\n new.icon_type = self.icon_type\\n new.id = 0\\n new.name = self.name\\n return new\",\n \"def modified(self, **attributes):\\n new_obj = deepcopy(self)\\n new_obj.__dict__.update(attributes)\\n new_obj.initialize()\\n return new_obj\",\n \"def copy(self):\\n cls = type(self)\\n # Create a new instance without calling __init__: parameters are\\n # different depending on the class.\\n new_box = cls.__new__(cls)\\n # Copy attributes\\n new_box.__dict__.update(self.__dict__)\\n return new_box\",\n \"def __init__(self, **kw):\\r\\n self.__dict__.update(kw)\",\n \"def __call__(cls, *args, **kwargs):\\n obj = type.__call__(cls, *args, **kwargs)\\n obj.initialize()\\n return obj\",\n \"def _get_all_attributes(self) -> Dict[str, Any]:\\n all_attributes = self.__dict__.copy()\\n all_attributes.update(self.class_attributes)\\n return all_attributes\",\n \"def clone(self):\\n memo = dict()\\n c = self._clone(memo)\\n c._clone_rip(memo)\\n return c\",\n \"def __new__(mcs, name, bases, attrs, **kwargs):\\r\\n attrs['__fields__'] = set()\\r\\n attrs['__store_attrs__'] = set()\\r\\n return super().__new__(mcs, name, bases, attrs, **kwargs)\",\n \"def _get_all_attributes(self):\\n all_attributes = self.__dict__.copy()\\n all_attributes.update(self.class_attributes)\\n return all_attributes\",\n \"def copy (self, **kwargs):\\n out = copy.deepcopy (self)\\n out.update (**kwargs)\\n return out\",\n \"def copy_with(self):\\n return self.copy()\",\n \"def copy(self):\\r\\n\\t\\tobj = DecaLink()\\r\\n\\t\\tfor k in self.__dict__.keys():\\r\\n\\t\\t\\tobj.__setattr__(k, self.__getattribute__(k))\\r\\n\\t\\treturn obj\",\n \"def copy(self):\\n return self.from_dict(self.to_dict(True))\",\n \"def _set_attributes(self):\",\n \"def copy(self):\\n out = type(self).__new__(self.__class__)\\n out.__dict__.update(self.__dict__)\\n # make sure the copy has its own unique random number generator\\n seed_seq = self.rng._bit_generator._seed_seq.spawn(1)[0]\\n out.__dict__['rng'] = get_generator(seed_seq)\\n return out\",\n \"def __call__(self, *args, **kwargs):\\n if not self.instance:\\n self.instance = super().__call__(*args, **kwargs)\\n return self.instance\",\n \"def clone(self) -> Any:\\n clone = super().clone()\\n clone.clear()\\n return clone\",\n \"def self(self):\\n attributelist = [k for k in type(self).__dict__ if not k.startswith(\\\"_\\\")]\\n return SelfWrapper(self, attributelist)\",\n \"def new_object(cls):\\n return cls.for_value([])\",\n \"def make_empty(cls):\\n args = inspect.getargspec(cls.__init__).args\\n # remove self; always first arg of __init__\\n args = args[1:]\\n return cls(**dict.fromkeys(args))\",\n \"def new_deconstruct(self):\\n name, path, args, kwargs = original_deconstruct(self)\\n for attr in IGNORED_ATTRS:\\n kwargs.pop(attr, None)\\n return name, path, args, kwargs\",\n \"def clone(self):\\n\\n copy = self.__class__(self.name, self.data)\\n\\n copy.set_fixed_variables_from_pdf(self)\\n \\n return copy\",\n \"def get(self) -> dict:\\n return clone(self.__dict__)\",\n \"def __init__(self, **kwargs):\\n # loop over the given kwargs\\n for key, value in kwargs.items():\\n # treat them like attribute assignments\\n setattr(self, key, value)\",\n \"def __copy__(self, *args, **kwargs):\\n return self.copy()\",\n \"def __init__(self, **initial_attributes):\\n\\n for attribute_name, attribute_value in initial_attributes.items():\\n setattr(self, attribute_name, attribute_value)\",\n \"def __copy__(self):\\n d = dict()\\n d.update(self.items())\\n return d\",\n \"def __copy__(self):\\n # prepare unnamed arguments\\n args = [getattr(self, arg) for arg in self._copy_conf['args']]\\n\\n # prepare named arguments\\n kwargs = {}\\n for arg in self._copy_conf['kwargs']:\\n # if arg is a tuple, the first entry will be the named kwargs, and\\n # the second will be the name of the attribute to copy\\n name = arg\\n if isinstance(arg, tuple):\\n name, arg = arg\\n if hasattr(self, arg):\\n kwargs[name] = getattr(self, arg)\\n\\n # create the new instance\\n new_copy = self.__class__(*args, **kwargs)\\n\\n # then copy attributes\\n for attr_name in self._copy_conf['attrs']:\\n if hasattr(self, attr_name):\\n setattr(new_copy, attr_name, getattr(self, attr_name))\\n\\n return new_copy\",\n \"def copy(self) -> AF:\\n if self._base == OrderedDict:\\n kopied = dict(self)\\n else:\\n kopied = self._base.copy(self)\\n return self.__class__(kopied, use_fuzzy=self.use_fuzzy, dottable=self._dottable)\",\n \"def copy(self):\\n new = self.__class__()\\n new.values = self.values.copy()\\n return new\",\n \"def __call__(self):\\n return self\",\n \"def copy(self):\\n\\n obj = MixedLMParams(self.k_fe, self.k_re, self.use_sqrt)\\n obj.set_packed(self.get_packed().copy())\\n return obj\",\n \"def __init__(self, *args, **kwargs):\\n super(AttrDict, self).__init__(*args, **kwargs)\\n self.__dict__ = self\",\n \"def clone(self):\\n return self\",\n \"def clone(self):\\r\\n obj = CylinderModel()\\r\\n obj.params = copy.deepcopy(self.params)\\r\\n return obj\",\n \"def rpConstruct(cls):\\r\\n return cls(None, None, None)\",\n \"def copy(self):\\n return self.__class__(self)\",\n \"def copy(self):\\n return self.__class__(self)\",\n \"def __init__(self, **attrs):\\n \\n # set given attributes\\n for name, value in attrs.items():\\n if hasattr(self, name):\\n setattr(self, name, value)\\n else:\\n raise AttributeError(\\\"Attribute not found! --> %s\\\" % name)\",\n \"def copy(self):\\n return self.from_builder(self)\",\n \"def _chain(self):\\n obj = self._clone()\\n if obj._sticky_filter:\\n obj.query.filter_is_sticky = True\\n obj._sticky_filter = False\\n return obj\",\n \"def __new__(cls, *args, **kwargs):\\n obj = super().__new__(cls)\\n obj.init_kwargs = cls.init_params(*args, **kwargs)\\n return obj\",\n \"def get_pure_data_copy(self):\\n import copy\\n data=copy.copy(self)\\n data.xp = data.xp.get_pure_data_copy()\\n data.timetable = data.timetable.get_pure_data_copy() \\n return data\",\n \"def clone(self, *args, **kwargs):\\n return self.copy().reset(*args, **kwargs)\",\n \"def __copy__(self):\\n return self.copy()\",\n \"def __init__(self, **kwargs):\\n for key, value in kwargs.items():\\n setattr(self, key, value)\",\n \"def _instantiate(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def __enter__(self):\\n self.__init__()\\n return self\",\n \"def __init__ (self, d):\\n try:\\n self.__dict__.update (d.__dict__)\\n except:\\n self.__dict__.update (d)\",\n \"def copy(self):\\n return self.__class__(self.items, self.is_cloud)\",\n \"def copy(self):\\n return self.__class__(*self.sets)\",\n \"def copy(self, **kwargs):\\n instance = copy(self)\\n kwargs.update({\\n 'id': None,\\n 'pk': None,\\n })\\n instance.update_from_kwargs(**kwargs)\\n return instance\",\n \"def build(self):\\n return ConnectionParams(self)\",\n \"def clone_and_update(self, **kwargs):\\n cloned = self.clone()\\n cloned.update(**kwargs)\\n return cloned\",\n \"def copy(self):\\r\\n # This way of initializing the copy means it works for subclasses, too.\\r\\n obj = self.__class__(self)\\r\\n obj.keyOrder = self.keyOrder[:]\\r\\n return obj\",\n \"def create(cls, **dictionary):\\n dummy_obj = cls(1, 1)\\n dummy_obj.update(**dictionary)\\n return dummy_obj\",\n \"def __init__(self, **kwargs):\\n\\t\\tself.vars = kwargs\\n\\t\\tself.old_vars = None\",\n \"def __init__(self, **kwargs):\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def __init__(self, **kwargs):\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def __init__(self, **kwargs):\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def __call__(self):\\n return self.cls(**self.kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6719594","0.6588282","0.6492425","0.643093","0.63870096","0.638417","0.638417","0.6381096","0.6337553","0.63111466","0.63078123","0.6277938","0.62500143","0.6229394","0.6193025","0.6179197","0.61522555","0.6148272","0.61313915","0.6122863","0.60904044","0.6086014","0.60714746","0.6063297","0.6057574","0.6047888","0.604346","0.60250974","0.60249645","0.6022907","0.60167235","0.60157955","0.60033685","0.5968656","0.59674555","0.5950479","0.59016436","0.5901489","0.58945596","0.58905464","0.5887986","0.58817744","0.5876314","0.58729494","0.5869359","0.5850585","0.58439","0.58429694","0.58242095","0.5813782","0.5807608","0.5792849","0.5786095","0.5780913","0.5777666","0.57734686","0.5772286","0.5771251","0.5755523","0.57413524","0.5736202","0.5735005","0.5734097","0.573367","0.57318336","0.5728331","0.57202506","0.5717001","0.5715953","0.57020986","0.5700471","0.56920666","0.5692005","0.5681355","0.5680032","0.566971","0.56681174","0.56681174","0.5657351","0.5655732","0.5651293","0.5649449","0.5647465","0.5640507","0.5629585","0.5624327","0.5622309","0.5616498","0.56152016","0.561236","0.56073827","0.5607368","0.5601215","0.55996466","0.55968","0.5589173","0.55890375","0.5585784","0.5585784","0.5585784","0.55852777"],"string":"[\n \"0.6719594\",\n \"0.6588282\",\n \"0.6492425\",\n \"0.643093\",\n \"0.63870096\",\n \"0.638417\",\n \"0.638417\",\n \"0.6381096\",\n \"0.6337553\",\n \"0.63111466\",\n \"0.63078123\",\n \"0.6277938\",\n \"0.62500143\",\n \"0.6229394\",\n \"0.6193025\",\n \"0.6179197\",\n \"0.61522555\",\n \"0.6148272\",\n \"0.61313915\",\n \"0.6122863\",\n \"0.60904044\",\n \"0.6086014\",\n \"0.60714746\",\n \"0.6063297\",\n \"0.6057574\",\n \"0.6047888\",\n \"0.604346\",\n \"0.60250974\",\n \"0.60249645\",\n \"0.6022907\",\n \"0.60167235\",\n \"0.60157955\",\n \"0.60033685\",\n \"0.5968656\",\n \"0.59674555\",\n \"0.5950479\",\n \"0.59016436\",\n \"0.5901489\",\n \"0.58945596\",\n \"0.58905464\",\n \"0.5887986\",\n \"0.58817744\",\n \"0.5876314\",\n \"0.58729494\",\n \"0.5869359\",\n \"0.5850585\",\n \"0.58439\",\n \"0.58429694\",\n \"0.58242095\",\n \"0.5813782\",\n \"0.5807608\",\n \"0.5792849\",\n \"0.5786095\",\n \"0.5780913\",\n \"0.5777666\",\n \"0.57734686\",\n \"0.5772286\",\n \"0.5771251\",\n \"0.5755523\",\n \"0.57413524\",\n \"0.5736202\",\n \"0.5735005\",\n \"0.5734097\",\n \"0.573367\",\n \"0.57318336\",\n \"0.5728331\",\n \"0.57202506\",\n \"0.5717001\",\n \"0.5715953\",\n \"0.57020986\",\n \"0.5700471\",\n \"0.56920666\",\n \"0.5692005\",\n \"0.5681355\",\n \"0.5680032\",\n \"0.566971\",\n \"0.56681174\",\n \"0.56681174\",\n \"0.5657351\",\n \"0.5655732\",\n \"0.5651293\",\n \"0.5649449\",\n \"0.5647465\",\n \"0.5640507\",\n \"0.5629585\",\n \"0.5624327\",\n \"0.5622309\",\n \"0.5616498\",\n \"0.56152016\",\n \"0.561236\",\n \"0.56073827\",\n \"0.5607368\",\n \"0.5601215\",\n \"0.55996466\",\n \"0.55968\",\n \"0.5589173\",\n \"0.55890375\",\n \"0.5585784\",\n \"0.5585784\",\n \"0.5585784\",\n \"0.55852777\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9498,"cells":{"query":{"kind":"string","value":"Method that returns a list of instances"},"document":{"kind":"string","value":"def load_from_file(cls):\n filename = cls.__name__ + \".json\"\n result = []\n try:\n with open(filename, encoding=\"utf-8\") as file:\n obj_list = cls.from_json_string(file.read())\n for dictionary in obj_list:\n result.append(cls.create(**dictionary))\n return result\n except:\n return result"},"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_instances(cls):\n raise NotImplementedError","def list_instances(self):\n # list instances\n self._list_instances()","async def get_instances(self, **kwargs) -> List[ApiResource]:\n raw_resources = await self.get_resources(**kwargs)\n _instances = [\n self._resource_factory(_raw)\n for _raw in self._loop_raw(raw_resources)\n ]\n return _instances","def getinstancelist():\n dbcursor_dict.execute(dbq.get_all_instance_list, )\n db_instance_list = dbcursor_dict.fetchall()\n return db_instance_list","def instances(self, **query):\n return self._list(_instance.Instance, **query)","def get(self):\r\n\t\treturn list(self)","def list_instances(self):\n nodes = self._driver.list_nodes()\n return [[n.name, n.state, n.public_ips] for n in nodes]","def instances(self):\n for d in os.listdir(self.directory):\n yield self.instance(self.directory, d)","def getinstances(cls):\n\t\t\tdead = set()\n\t\t\tfor ref in cls._instances:\n\t\t\t\tobj = ref()\n\t\t\t\tif obj is not None:\n\t\t\t\t\tyield obj\n\t\t\t\telse:\n\t\t\t\t\tdead.add(ref)\n\t\t\tcls._instances -= dead","def instances(self):\n return self.get('instances')","def list(self) -> list:\n return list(self)","def get_many(cls, limit: int = 100, offset: int = 0):\n if limit > 100:\n raise ModelExceptions(\"It is not possible to list more than 100 resources.\")\n\n instance_list = DBSESSION.query(cls)\n instance_list = instance_list.order_by(cls.id)\n instance_list = instance_list.offset(offset)\n instance_list = instance_list.limit(limit)\n instance_list = instance_list.all()\n if not instance_list:\n raise ObjectNotFound(f\"No registers of {cls.str_representation} found\")\n\n return instance_list","def get_instances(cls, recursive=False):\n instances = list(cls._instances)\n if recursive:\n for Child in cls.__subclasses__():\n instances += Child.get_instances(recursive=recursive)\n\n # Remove duplicates from multiple inheritance.\n return list(set(instances))","def instances(self):\r\n # It would be more efficient to do this with filters now\r\n # but not all services that implement EC2 API support filters.\r\n instances = []\r\n rs = self.connection.get_all_instances()\r\n for reservation in rs:\r\n uses_group = [g.name for g in reservation.groups if g.name == self.name]\r\n if uses_group:\r\n instances.extend(reservation.instances)\r\n return instances","def getList(self):","def getList(self):","def _instancelist(self):\n\n rv = []\n self.iname = {}\n for resv in self.conn.get_all_reservations():\n for inst in resv.instances:\n if inst.state != 'terminated':\n name = inst.tags.get('Name',None)\n rv.append([inst.id,inst.state])\n if name is not None:\n rv.append([name,inst.state])\n else:\n rv.append([inst.id+'-needsName',inst.state])\n self.iname[name] = inst.id\n self.iname[inst.id] = inst.id\n return rv","def __iter__(self):\n\n return [self]","def __iter__(self):\n\n return [self]","def list(self):\r\n return List(self)","def list(self):\r\n return List(self)","def list(self):\r\n return List(self)","def list_(args):\n\n # Get Config.py\n cloud = get_current_cloud(args.cloud)\n\n instances = cloud.list_instances()\n print_table(print_instance_summary, headers, instances,\n use_color=args.color)\n return instances","def get_all_cached_instances(cls):\n return list(cls.__dbclass__.__instance_cache__.values())","def get_instance_classes():\n return Base_Instance.get_instance_classes()","def show_instances():\n return get_instances()","def all(self, *args, **kwargs):\n list_to_return = []\n if not self.object_type:\n return list_to_return\n class_name = eval(self.object_type)\n if self.objects_id:\n for id in self.objects_id.split(';'):\n if id:\n list_to_return.append(class_name.objects.get(id=id))\n return list_to_return","def query_all(cls)->List:\n database.cursor.execute(\"SELECT * FROM {}\".format(cls.table_name))\n items = database.cursor.fetchall()\n return [cls.to_object(item) for item in items]","def instances(cls):\n # clean garbage collected pkgs out of __instances\n cls.__instances[:] = [wkref for wkref in cls.__instances\n if wkref() is not None]\n # return instance references in a tuple\n pkgs = [wkref() for wkref in cls.__instances]\n return tuple(pkgs)","def get_instances(self) -> List[Instance]:\n\n def download_and_read_lines(file_name: str) -> List[str]:\n file_path: str = os.path.join(data_path, file_name)\n ensure_file_downloaded(\n source_url=MeQSumScenario.SOURCE_URL_TEMPLATE.format(file_name=file_name),\n target_path=file_path,\n unpack=False,\n )\n\n with open(file_path) as f:\n return f.read().splitlines()\n\n data_path: str = os.path.join(self.output_path, \"data\")\n ensure_directory_exists(data_path)\n\n instances: List[Instance] = []\n for split in ALL_SPLITS:\n dataset_split: str = \"val\" if split == VALID_SPLIT else split\n\n # The files with the questions end with \".source\"\n questions: List[str] = download_and_read_lines(f\"{dataset_split}.source\")\n\n # The files with the summaries end with \".target\"\n summaries: List[str] = download_and_read_lines(f\"{dataset_split}.target\")\n\n for question, summary in zip(questions, summaries):\n instances.append(\n Instance(\n input=Input(text=question),\n references=[Reference(output=Output(text=summary), tags=[CORRECT_TAG])],\n split=split,\n )\n )\n\n return instances","def objects (self):\n return InternalObjectList (self)","def getList(self):\n pass","def list(self):","def vnf_instances(self) -> Iterator[VnfInstance]:\n return self._get_related_instance(VnfInstance, \"generic-vnf\")","def GetInstances(self, bulk=False, reason=None):\n query = []\n _AppendIf(query, bulk, (\"bulk\", 1))\n _AppendReason(query, reason)\n\n instances = self._SendRequest(HTTP_GET,\n \"/%s/instances\" % GANETI_RAPI_VERSION,\n query, None)\n if bulk:\n return instances\n else:\n return [i[\"id\"] for i in instances]","def list(self):\n return self._get_list()","def list(cls):\n return [cls.__dict__.get(name) for name in dir(cls) if (\n not callable(getattr(cls, name)) and not name.startswith(\"_\")\n )]","def list_instances(self):\n\n response = self.client.service.instances().aggregatedList(\n project=self.client.project_id).execute()\n\n zones = response.get('items', {})\n instances = []\n for zone in zones.values():\n for instance in zone.get('instances', []):\n instances.append(instance)\n\n return instances","def _list(self):\n raise NotImplementedError","def persons(self):\r\n return persons.Persons(self)","def all(self):\n return list(self)","def objects(self):","def instances():\n mydict = db.hgetall(application_name)\n ordered = OrderedDict()\n for key in sorted(mydict):\n ordered.__setitem__(key,mydict.get(key))\n mylist = []\n return render_template('robots.html', mydict=ordered)","def list_instances(self):\n instances = utils.list_instances(self.compute_client,\n drv_conf.resource_group)\n\n self._uuid_to_omni_instance.clear()\n instance_names = []\n for instance in instances:\n openstack_id = None\n if instance.tags and 'openstack_id' in instance.tags:\n openstack_id = instance.tags['openstack_id']\n if openstack_id is None:\n openstack_id = self._get_uuid_from_omni_id(instance.name)\n self._uuid_to_omni_instance[openstack_id] = instance\n instance_names.append(instance.name)\n return instance_names","def get_instances(self) -> List[Instance]:\n big_bench_task: Dict = BIGBenchScenario.download_and_get_task(self.output_path, self.task, self.subtask)\n\n # From https://github.com/google/BIG-bench/blob/main/docs/doc.md#json-schema,\n # \"keywords\", \"description\" and \"examples\" are all required fields for a BIG-bench task.\n # keywords: \"A list of strings, where each string contains a separate keyword describing the task\"\n self.tags = big_bench_task[\"keywords\"]\n\n # description: \"A plaintext description of the task, suitable for a non-expert to perform the task and\n # potentially generate new examples.\"\n # Append the task, subtask and task-specific description from BIG-bench to `description`.\n self.description = (\n f\"{self.description} Task: {self.task} \"\n f\"{f'Subtask: {self.subtask} ' if self.subtask else ''} \"\n f\"Description: {big_bench_task['description']}\"\n )\n\n # examples: \"A list of dicts\"\n examples: List[Dict] = big_bench_task[\"examples\"]\n # Before splitting the data, shuffle the examples with a fixed seed for reproducibility.\n random.seed(0)\n random.shuffle(examples)\n\n # BIG-bench split the data according to\n # https://github.com/google/BIG-bench/blob/main/bigbench/bbseqio/README.md#splits:\n # all: This contains all the examples.\n # validation: This contains 20% of the examples or at least 16 examples.\n # train: All examples that are not in the validation split (generally 80% of the examples)\n # For few-shot eval, use the all split.\n #\n # TODO: I'm not sure what they mean by \"for few-shot eval, use the all split.\"\n # Does that mean they don't draw in-context examples from a separate train split?\n #\n # We split the data as follows:\n # test: This contains 20% of the examples or at least 16 examples.\n # validation: Same size as the test split.\n # train: Remaining examples, not in the test and validation splits.\n total_examples: int = len(examples)\n num_test_examples: int = max(int(0.2 * total_examples), BIGBenchScenario.MIN_TEST_EXAMPLES)\n num_train_examples: int = total_examples - num_test_examples * 2\n\n # Build `Instance`s from `examples`.\n instances: List[Instance] = []\n for i, example in enumerate(examples):\n # Build references.\n references: List[Reference]\n\n # Each example has \"input\" and either \"target_scores\" or \"target\".\n if \"target_scores\" in example:\n # For \"target_scores\", BIG-bench compares target scores against the model's predicted probabilities:\n # \"The example score is then the target score (as specified in the target_scores dict) of the target\n # that received the highest probability. Scores are averaged across examples. Conventional\n # multiple-choice accuracy can be achieved by assigning the correct target a score of 1, and\n # all incorrect targets a score of 0.\"\n # It seems all BIG-bench Lite tasks with target scores either have a target score\n # of 0 (incorrect answer) or 1 (correct answer).\n # So, for now, `Reference`s with the highest target score are correct.\n highest_score = max(example[\"target_scores\"].values())\n references = [\n Reference(Output(text=target), tags=[CORRECT_TAG] if score == highest_score else [])\n for target, score in example[\"target_scores\"].items()\n ]\n elif \"target\" in example:\n # All the outputs in \"target\" are correct e.g., {\"input\": \"1 + 1 = \", \"target\": [\"two\",\"2\"]}.\n # \"target\" can either be a list of correct values or a single correct value.\n targets: List[str] = example[\"target\"] if type(example[\"target\"]) == list else [example[\"target\"]]\n references = [Reference(Output(text=target), tags=[CORRECT_TAG]) for target in targets]\n else:\n raise ValueError(f\"Invalid example that doesn't have `target` or `target_scores` field: {example}\")\n\n # Get split based on current index `i`.\n split: str\n if i < num_train_examples:\n split = TRAIN_SPLIT\n elif num_train_examples <= i < num_train_examples + num_test_examples:\n split = TEST_SPLIT\n else:\n split = VALID_SPLIT\n\n instances.append(Instance(Input(text=example[\"input\"]), references, split=split))\n\n return instances","def fetch_all(self):\n return list(iter(self))","def all_model_instances(self) -> Iterator['panda_core_data.model.Model']:\n for current_type in self.all_models:\n for current_instance in current_type.all_instances:\n yield current_instance","def load_from_file(cls):\n if path.exists(cls.__name__ + \".json\") is False:\n return []\n with open(cls.__name__ + \".json\", \"r\", encoding='utf-8') as file:\n listofinstances = []\n objectlist = cls.from_json_string(file.read())\n for dict in objectlist:\n objectdict = {}\n for key, value in dict.items():\n objectdict[key] = value\n listofinstances.append(cls.create(**objectdict))\n return listofinstances","def list_instance_uuids(self):\n return self.list_instances()","def GetObjects(self): \r\n return self.model.GetObjects()","def get_by_cls(self, cls: GObject.GType) -> typ.List[Gst.Element]:\n elements = self._pipeline.iterate_elements()\n if isinstance(elements, Gst.Iterator):\n # Patch \"TypeError: ‘Iterator’ object is not iterable.\"\n # For versions we have to get a python iterable object from Gst iterator\n _elements = []\n while True:\n ret, el = elements.next()\n if ret == Gst.IteratorResult(1): # GST_ITERATOR_OK\n _elements.append(el)\n else:\n break\n elements = _elements\n\n return [e for e in elements if isinstance(e, cls)]","def list(self, *args):\n return []","def get_instances(self):\n connection = self.connection\n\n instances = []\n\n connection.row_factory = sqlite3.Row\n cur = connection.cursor()\n cur.execute(\"SELECT * FROM INSTANCES\")\n rows = cur.fetchall()\n columns = [str(i[0]).lower() for i in cur.description]\n for row in rows:\n object = dict(zip(columns, row))\n instances.append(object)\n\n instancesNoneDict = {}\n\n for instance in instances:\n if instance['harvesterid'] not in instancesNoneDict:\n instancesNoneDict[instance['harvesterid']] = {}\n if instance['harvesterhost'] not in instancesNoneDict[instance['harvesterid']]:\n instancesNoneDict[instance['harvesterid']][instance['harvesterhost']] = {\n 'availability': instance['availability'], 'errorsdesc': instance['errorsdesc'],\n 'contacts': instance['contacts'].split(','),\n 'active': instance['active'], 'notificated': instance['notificated']}\n elif instance['harvesterid'] in instancesNoneDict:\n if instance['harvesterhost'] not in instancesNoneDict[instance['harvesterid']]:\n instancesNoneDict[instance['harvesterid']][instance['harvesterhost']] = {\n 'availability': instance['availability'], 'errorsdesc': instance['errorsdesc'],\n 'contacts': instance['contacts'].split(','),\n 'active': instance['active'], 'notificated': instance['notificated']}\n if 'none' in instancesNoneDict[instance['harvesterid']]:\n del instancesNoneDict[instance['harvesterid']]['none']\n return instancesNoneDict","def fetch_instances(self, ids):\n result = []\n self.log.info(f\"fetch '{len(ids)}' instances\")\n self.log.debug(f\"fetch instance data for ids '{ids}'\")\n try:\n response = self.client.describe_instances(\n InstanceIds=ids\n )\n if 'HTTPStatusCode' in response['ResponseMetadata'] and response['ResponseMetadata']['HTTPStatusCode'] == 200:\n pass\n else:\n raise Exception(f'not able to fetch instacnes with ids: {ids}')\n if len(response['Reservations'][0]['Instances']) == 0:\n raise Exception(f'should retrun at least single insatance data')\n result = []\n for reservation in response[\"Reservations\"]:\n for el in reservation[\"Instances\"]:\n ec2 = EC2Instance.factory(el)\n if ec2.state:\n result.append(ec2)\n else:\n self.log.warn(f'instance \"{ec2.id}\" excluded')\n except Exception as e:\n raise Exception(f'exception when trying to fetch instance data {ids}')\n return sorted(list(result), key=lambda instance: instance.launch_time)","def get_instances_to_forward(self, definition: Definition) -> List[str]:\n if not definition in self._internal_book:\n return []\n return [\n instance_name\n for instance_name, definitions in self.book.items()\n if definition in definitions\n ]","def list_instances(self):\n LOG.debug(\"list_instances\")\n\n instance_ids = []\n bmms = db.bmm_get_all(None)\n for bmm in bmms:\n if not bmm[\"instance_id\"]:\n continue\n instance_ids.append(self._instance_id_to_name(bmm[\"instance_id\"]))\n\n return instance_ids","def getXeprInstances():\n apilib = _loadapilib()\n instances = _findInst(apilib)\n return dict([(p, t) for p, t in instances])","def get_all(self):\n return [_ for _ in self]","def getAllCls(cls):\n newlist = list(clslist)\n return newlist","def get_all(cls):\n return DataStore.get_all_instance(cls)","def list_instances():\n if request.method == \"GET\":\n return render_template(\"instances.html\")","def getList(self):\n\treturn self.list","def iter(self):\n return []","def get_instances_by_tags(self, tags):\n return self.get_only_instances(filters={'tag:{}'.format(key): val for key, val in tags.items()})","def get_instance_classes():\n return Base_Instance.instance_classes","def list(self):\n return self.objects.all()","def load_from_file(cls):\n lists = []\n filename = cls.__name__ + \".json\"\n try:\n with open(filename, \"r\") as f:\n instances = cls.from_json_string(f.read())\n for k, v in enumerate(instances):\n lists.append(cls.create(**instances[k]))\n\n except:\n pass\n return lists","def lists(self):\r\n return Lists(self)","def _get_all_records(self) -> List[DBModelInstance]:\n return self.model.query.all()","def get_instance_list():\n return parse_list_output(Popen('nova list --all-tenants'.split(),\n stdout=STDOUT, stderr=STDERR).communicate()[0])","def find_objs(self, cls, **attr):\n nodes = getattr(self.graph, getattr(models, cls).element_plural).query(**attr).all()\n return nodes","def obj_list(self):\n return self._obj_list","def all(cls):\n return []","def get_objects(self):\n return self._objects","def get_all(cls):\n return db_session.query(cls).order_by(cls.name).all()","def do_all(self, *args):\n args = [ele for ele in args[0].split(' ')]\n print_obj = []\n storage.reload()\n if args[0] == '':\n for key, obj in storage.all().items():\n print_obj.append(obj.__str__())\n print(print_obj)\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n else:\n ''' Get a list of specified instances '''\n for key, obj in storage.all().items():\n key = key.split('.')\n if key[0] == args[0]:\n print_obj.append(obj.__str__())\n print(print_obj)","def get_list(self):\n return self.__repository.get_all()","def create_list(cls, *args):\n return _create_list(cls, *args)","def create_list(cls, *args):\n return _create_list(cls, *args)","def get_records(self) -> List[DBModelInstance]:\n return self._get_all_records()","def __toObjList(self, cursor, className):\n lst = []\n for row in cursor.fetchall():\n # first convert row to a dictionary\n rowdict={}\n for idx, col in enumerate(cursor.description):\n memberName = col[0].strip().replace(' ', '__')\n rowdict[memberName] = row[idx]\n # create class of type and set properties to dictionary\n instance = type(className, (), rowdict)\n lst.append(instance)\n return lst","def list_instances():\n js = _get_jetstream_conn()\n il = js.compute.instances.list()\n if not il:\n msg = \"You don't have any instances available.\"\n else:\n msg = (\"You have {0} instances available. Here are up to 3 most \"\n \"recent: \".format(len(il)))\n msg_ex = \"\"\n content = \"\"\n for i in il[:3]:\n msg_ex += \"{0},\".format(i.name)\n content += \"{0} ({1})\\n\".format(\n i.name, i.public_ips[0] if i.public_ips else i.private_ips[0])\n return statement(msg + msg_ex).simple_card(title=msg, content=content)","def _generate_instances(self, single_traj):\n return [single_traj[:2].values]","def instances(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"instances\")","def get_instances_of_class(cls, folder):\n data = list()\n for _, _, filenames in os.walk(folder):\n for filename in filenames:\n if filename.endswith(\".jpg\"):\n last = filename.split(\"/\")[-1]\n if re.match(cls, last):\n data.append(last)\n return data","def all(cls):\n return (cls(**client) for client in cls.collection().find({}))","def get_instances(self, region):\n try:\n conn = ec2.connect_to_region(region, **self.credentials)\n region_instances = []\n reservations = conn.get_all_reservations()\n for reservation in reservations:\n for instance in reservation.instances:\n region_instances.append(instance)\n except boto.exception.EC2ResponseError:\n return []\n return region_instances","def list_instances(self):\n instances = []\n try:\n pages = self.compute.virtual_machines.list(\n CONF.azure.resource_group)\n except Exception as e:\n msg = six.text_type(e)\n LOG.exception(msg)\n ex = exception.InstanceListFailure(reason=six.text_type(e))\n raise ex\n else:\n if pages:\n for i in pages:\n instances.append(i.name)\n return instances","def get_elements(self):\n query = f\"select name, middle_name, last_name, age from `{self.table_id}`\"\n query_job = self.client.query(query)\n clients = []\n for row in query_job:\n print('Name', row['name'], 'middle name:', row['middle_name'], 'last name: ',row['last_name'], 'age:', row['age'])\n clients.append(Client(row['name'],row['middle_name'],row['last_name'],row['age']))\n return clients","def get_list(self, *args, **kwargs):\n pass","def get_list(self, *args, **kwargs):\n pass","def objects(self):\n\t\treturn self._objects","def yield_instances(self, instance_filter=None):\n if instance_filter and set(\"\\\"\\\\'\").intersection(instance_filter):\n raise ValueError('Invalid instance filter: %s' % instance_filter)\n page_token = None\n while True:\n params = {'maxResults': 250}\n if instance_filter:\n params['filter'] = 'name eq \"%s\"' % instance_filter\n if page_token:\n params['pageToken'] = page_token\n resp = self.call_api('/aggregated/instances', params=params, deadline=120)\n items = resp.get('items', {})\n for zone in sorted(items):\n for instance in items[zone].get('instances', []):\n yield instance\n page_token = resp.get('nextPageToken')\n if not page_token:\n break","def get_activities(cls):\n objs = cls.objects\n return objs","def __get_multi_instances(self, reservations, instance_ids=None, policies=None):\n check_instance_ids = False\n if ( instance_ids and len(instance_ids) > 0 ):\n check_instance_ids = True\n instances = [] \n for reservation in reservations:\n if check_instance_ids:\n for instance in reservation.instances:\n if instance.id in instance_ids:\n instances.append(instance)\n elif policies:\n for instance in reservation.instances:\n if 'typevm' in policies and instance.instance_type == policies['typevm']:\n instances.append(instance) \n elif policies.get('level')==1:\n if self.__compare_types_instances(policies, instance.instance_type.encode(\"latin-1\")):\n instances.append(instance)\n elif policies.get('level') == 0:\n if self.__is_adaptive_instance(self.__get_metrics_adapted(policies), instance.instance_type.encode(\"latin-1\")):\n instances.append(instance)\n else:\n instances=[]\n else:\n instances += reservation.instances\n return instances, len(instances)","def list_instances(self, label_filters: Optional[dict] = None) -> List[\"GCPNode\"]:\n return","def filter(self, cls):\n return ElementList([x for x in self._elements if isinstance(x, cls)])","def _get_instances(instance_tags, region):\n return ec2_conn[region].get_all_instances(filters={\"tag:Name\": instance_tags})","def all(self):\n return (self.__objects)","def all(cls):\n api = BuslineAPI()\n try:\n objects = api.all()\n except ApiException:\n objects = cls.objects.all()\n return objects","def get_instance_essentials(self):\n ret = []\n for instance in self.all_instances:\n ret.append(instance.get_essentials())\n return ret"],"string":"[\n \"def get_instances(cls):\\n raise NotImplementedError\",\n \"def list_instances(self):\\n # list instances\\n self._list_instances()\",\n \"async def get_instances(self, **kwargs) -> List[ApiResource]:\\n raw_resources = await self.get_resources(**kwargs)\\n _instances = [\\n self._resource_factory(_raw)\\n for _raw in self._loop_raw(raw_resources)\\n ]\\n return _instances\",\n \"def getinstancelist():\\n dbcursor_dict.execute(dbq.get_all_instance_list, )\\n db_instance_list = dbcursor_dict.fetchall()\\n return db_instance_list\",\n \"def instances(self, **query):\\n return self._list(_instance.Instance, **query)\",\n \"def get(self):\\r\\n\\t\\treturn list(self)\",\n \"def list_instances(self):\\n nodes = self._driver.list_nodes()\\n return [[n.name, n.state, n.public_ips] for n in nodes]\",\n \"def instances(self):\\n for d in os.listdir(self.directory):\\n yield self.instance(self.directory, d)\",\n \"def getinstances(cls):\\n\\t\\t\\tdead = set()\\n\\t\\t\\tfor ref in cls._instances:\\n\\t\\t\\t\\tobj = ref()\\n\\t\\t\\t\\tif obj is not None:\\n\\t\\t\\t\\t\\tyield obj\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdead.add(ref)\\n\\t\\t\\tcls._instances -= dead\",\n \"def instances(self):\\n return self.get('instances')\",\n \"def list(self) -> list:\\n return list(self)\",\n \"def get_many(cls, limit: int = 100, offset: int = 0):\\n if limit > 100:\\n raise ModelExceptions(\\\"It is not possible to list more than 100 resources.\\\")\\n\\n instance_list = DBSESSION.query(cls)\\n instance_list = instance_list.order_by(cls.id)\\n instance_list = instance_list.offset(offset)\\n instance_list = instance_list.limit(limit)\\n instance_list = instance_list.all()\\n if not instance_list:\\n raise ObjectNotFound(f\\\"No registers of {cls.str_representation} found\\\")\\n\\n return instance_list\",\n \"def get_instances(cls, recursive=False):\\n instances = list(cls._instances)\\n if recursive:\\n for Child in cls.__subclasses__():\\n instances += Child.get_instances(recursive=recursive)\\n\\n # Remove duplicates from multiple inheritance.\\n return list(set(instances))\",\n \"def instances(self):\\r\\n # It would be more efficient to do this with filters now\\r\\n # but not all services that implement EC2 API support filters.\\r\\n instances = []\\r\\n rs = self.connection.get_all_instances()\\r\\n for reservation in rs:\\r\\n uses_group = [g.name for g in reservation.groups if g.name == self.name]\\r\\n if uses_group:\\r\\n instances.extend(reservation.instances)\\r\\n return instances\",\n \"def getList(self):\",\n \"def getList(self):\",\n \"def _instancelist(self):\\n\\n rv = []\\n self.iname = {}\\n for resv in self.conn.get_all_reservations():\\n for inst in resv.instances:\\n if inst.state != 'terminated':\\n name = inst.tags.get('Name',None)\\n rv.append([inst.id,inst.state])\\n if name is not None:\\n rv.append([name,inst.state])\\n else:\\n rv.append([inst.id+'-needsName',inst.state])\\n self.iname[name] = inst.id\\n self.iname[inst.id] = inst.id\\n return rv\",\n \"def __iter__(self):\\n\\n return [self]\",\n \"def __iter__(self):\\n\\n return [self]\",\n \"def list(self):\\r\\n return List(self)\",\n \"def list(self):\\r\\n return List(self)\",\n \"def list(self):\\r\\n return List(self)\",\n \"def list_(args):\\n\\n # Get Config.py\\n cloud = get_current_cloud(args.cloud)\\n\\n instances = cloud.list_instances()\\n print_table(print_instance_summary, headers, instances,\\n use_color=args.color)\\n return instances\",\n \"def get_all_cached_instances(cls):\\n return list(cls.__dbclass__.__instance_cache__.values())\",\n \"def get_instance_classes():\\n return Base_Instance.get_instance_classes()\",\n \"def show_instances():\\n return get_instances()\",\n \"def all(self, *args, **kwargs):\\n list_to_return = []\\n if not self.object_type:\\n return list_to_return\\n class_name = eval(self.object_type)\\n if self.objects_id:\\n for id in self.objects_id.split(';'):\\n if id:\\n list_to_return.append(class_name.objects.get(id=id))\\n return list_to_return\",\n \"def query_all(cls)->List:\\n database.cursor.execute(\\\"SELECT * FROM {}\\\".format(cls.table_name))\\n items = database.cursor.fetchall()\\n return [cls.to_object(item) for item in items]\",\n \"def instances(cls):\\n # clean garbage collected pkgs out of __instances\\n cls.__instances[:] = [wkref for wkref in cls.__instances\\n if wkref() is not None]\\n # return instance references in a tuple\\n pkgs = [wkref() for wkref in cls.__instances]\\n return tuple(pkgs)\",\n \"def get_instances(self) -> List[Instance]:\\n\\n def download_and_read_lines(file_name: str) -> List[str]:\\n file_path: str = os.path.join(data_path, file_name)\\n ensure_file_downloaded(\\n source_url=MeQSumScenario.SOURCE_URL_TEMPLATE.format(file_name=file_name),\\n target_path=file_path,\\n unpack=False,\\n )\\n\\n with open(file_path) as f:\\n return f.read().splitlines()\\n\\n data_path: str = os.path.join(self.output_path, \\\"data\\\")\\n ensure_directory_exists(data_path)\\n\\n instances: List[Instance] = []\\n for split in ALL_SPLITS:\\n dataset_split: str = \\\"val\\\" if split == VALID_SPLIT else split\\n\\n # The files with the questions end with \\\".source\\\"\\n questions: List[str] = download_and_read_lines(f\\\"{dataset_split}.source\\\")\\n\\n # The files with the summaries end with \\\".target\\\"\\n summaries: List[str] = download_and_read_lines(f\\\"{dataset_split}.target\\\")\\n\\n for question, summary in zip(questions, summaries):\\n instances.append(\\n Instance(\\n input=Input(text=question),\\n references=[Reference(output=Output(text=summary), tags=[CORRECT_TAG])],\\n split=split,\\n )\\n )\\n\\n return instances\",\n \"def objects (self):\\n return InternalObjectList (self)\",\n \"def getList(self):\\n pass\",\n \"def list(self):\",\n \"def vnf_instances(self) -> Iterator[VnfInstance]:\\n return self._get_related_instance(VnfInstance, \\\"generic-vnf\\\")\",\n \"def GetInstances(self, bulk=False, reason=None):\\n query = []\\n _AppendIf(query, bulk, (\\\"bulk\\\", 1))\\n _AppendReason(query, reason)\\n\\n instances = self._SendRequest(HTTP_GET,\\n \\\"/%s/instances\\\" % GANETI_RAPI_VERSION,\\n query, None)\\n if bulk:\\n return instances\\n else:\\n return [i[\\\"id\\\"] for i in instances]\",\n \"def list(self):\\n return self._get_list()\",\n \"def list(cls):\\n return [cls.__dict__.get(name) for name in dir(cls) if (\\n not callable(getattr(cls, name)) and not name.startswith(\\\"_\\\")\\n )]\",\n \"def list_instances(self):\\n\\n response = self.client.service.instances().aggregatedList(\\n project=self.client.project_id).execute()\\n\\n zones = response.get('items', {})\\n instances = []\\n for zone in zones.values():\\n for instance in zone.get('instances', []):\\n instances.append(instance)\\n\\n return instances\",\n \"def _list(self):\\n raise NotImplementedError\",\n \"def persons(self):\\r\\n return persons.Persons(self)\",\n \"def all(self):\\n return list(self)\",\n \"def objects(self):\",\n \"def instances():\\n mydict = db.hgetall(application_name)\\n ordered = OrderedDict()\\n for key in sorted(mydict):\\n ordered.__setitem__(key,mydict.get(key))\\n mylist = []\\n return render_template('robots.html', mydict=ordered)\",\n \"def list_instances(self):\\n instances = utils.list_instances(self.compute_client,\\n drv_conf.resource_group)\\n\\n self._uuid_to_omni_instance.clear()\\n instance_names = []\\n for instance in instances:\\n openstack_id = None\\n if instance.tags and 'openstack_id' in instance.tags:\\n openstack_id = instance.tags['openstack_id']\\n if openstack_id is None:\\n openstack_id = self._get_uuid_from_omni_id(instance.name)\\n self._uuid_to_omni_instance[openstack_id] = instance\\n instance_names.append(instance.name)\\n return instance_names\",\n \"def get_instances(self) -> List[Instance]:\\n big_bench_task: Dict = BIGBenchScenario.download_and_get_task(self.output_path, self.task, self.subtask)\\n\\n # From https://github.com/google/BIG-bench/blob/main/docs/doc.md#json-schema,\\n # \\\"keywords\\\", \\\"description\\\" and \\\"examples\\\" are all required fields for a BIG-bench task.\\n # keywords: \\\"A list of strings, where each string contains a separate keyword describing the task\\\"\\n self.tags = big_bench_task[\\\"keywords\\\"]\\n\\n # description: \\\"A plaintext description of the task, suitable for a non-expert to perform the task and\\n # potentially generate new examples.\\\"\\n # Append the task, subtask and task-specific description from BIG-bench to `description`.\\n self.description = (\\n f\\\"{self.description} Task: {self.task} \\\"\\n f\\\"{f'Subtask: {self.subtask} ' if self.subtask else ''} \\\"\\n f\\\"Description: {big_bench_task['description']}\\\"\\n )\\n\\n # examples: \\\"A list of dicts\\\"\\n examples: List[Dict] = big_bench_task[\\\"examples\\\"]\\n # Before splitting the data, shuffle the examples with a fixed seed for reproducibility.\\n random.seed(0)\\n random.shuffle(examples)\\n\\n # BIG-bench split the data according to\\n # https://github.com/google/BIG-bench/blob/main/bigbench/bbseqio/README.md#splits:\\n # all: This contains all the examples.\\n # validation: This contains 20% of the examples or at least 16 examples.\\n # train: All examples that are not in the validation split (generally 80% of the examples)\\n # For few-shot eval, use the all split.\\n #\\n # TODO: I'm not sure what they mean by \\\"for few-shot eval, use the all split.\\\"\\n # Does that mean they don't draw in-context examples from a separate train split?\\n #\\n # We split the data as follows:\\n # test: This contains 20% of the examples or at least 16 examples.\\n # validation: Same size as the test split.\\n # train: Remaining examples, not in the test and validation splits.\\n total_examples: int = len(examples)\\n num_test_examples: int = max(int(0.2 * total_examples), BIGBenchScenario.MIN_TEST_EXAMPLES)\\n num_train_examples: int = total_examples - num_test_examples * 2\\n\\n # Build `Instance`s from `examples`.\\n instances: List[Instance] = []\\n for i, example in enumerate(examples):\\n # Build references.\\n references: List[Reference]\\n\\n # Each example has \\\"input\\\" and either \\\"target_scores\\\" or \\\"target\\\".\\n if \\\"target_scores\\\" in example:\\n # For \\\"target_scores\\\", BIG-bench compares target scores against the model's predicted probabilities:\\n # \\\"The example score is then the target score (as specified in the target_scores dict) of the target\\n # that received the highest probability. Scores are averaged across examples. Conventional\\n # multiple-choice accuracy can be achieved by assigning the correct target a score of 1, and\\n # all incorrect targets a score of 0.\\\"\\n # It seems all BIG-bench Lite tasks with target scores either have a target score\\n # of 0 (incorrect answer) or 1 (correct answer).\\n # So, for now, `Reference`s with the highest target score are correct.\\n highest_score = max(example[\\\"target_scores\\\"].values())\\n references = [\\n Reference(Output(text=target), tags=[CORRECT_TAG] if score == highest_score else [])\\n for target, score in example[\\\"target_scores\\\"].items()\\n ]\\n elif \\\"target\\\" in example:\\n # All the outputs in \\\"target\\\" are correct e.g., {\\\"input\\\": \\\"1 + 1 = \\\", \\\"target\\\": [\\\"two\\\",\\\"2\\\"]}.\\n # \\\"target\\\" can either be a list of correct values or a single correct value.\\n targets: List[str] = example[\\\"target\\\"] if type(example[\\\"target\\\"]) == list else [example[\\\"target\\\"]]\\n references = [Reference(Output(text=target), tags=[CORRECT_TAG]) for target in targets]\\n else:\\n raise ValueError(f\\\"Invalid example that doesn't have `target` or `target_scores` field: {example}\\\")\\n\\n # Get split based on current index `i`.\\n split: str\\n if i < num_train_examples:\\n split = TRAIN_SPLIT\\n elif num_train_examples <= i < num_train_examples + num_test_examples:\\n split = TEST_SPLIT\\n else:\\n split = VALID_SPLIT\\n\\n instances.append(Instance(Input(text=example[\\\"input\\\"]), references, split=split))\\n\\n return instances\",\n \"def fetch_all(self):\\n return list(iter(self))\",\n \"def all_model_instances(self) -> Iterator['panda_core_data.model.Model']:\\n for current_type in self.all_models:\\n for current_instance in current_type.all_instances:\\n yield current_instance\",\n \"def load_from_file(cls):\\n if path.exists(cls.__name__ + \\\".json\\\") is False:\\n return []\\n with open(cls.__name__ + \\\".json\\\", \\\"r\\\", encoding='utf-8') as file:\\n listofinstances = []\\n objectlist = cls.from_json_string(file.read())\\n for dict in objectlist:\\n objectdict = {}\\n for key, value in dict.items():\\n objectdict[key] = value\\n listofinstances.append(cls.create(**objectdict))\\n return listofinstances\",\n \"def list_instance_uuids(self):\\n return self.list_instances()\",\n \"def GetObjects(self): \\r\\n return self.model.GetObjects()\",\n \"def get_by_cls(self, cls: GObject.GType) -> typ.List[Gst.Element]:\\n elements = self._pipeline.iterate_elements()\\n if isinstance(elements, Gst.Iterator):\\n # Patch \\\"TypeError: ‘Iterator’ object is not iterable.\\\"\\n # For versions we have to get a python iterable object from Gst iterator\\n _elements = []\\n while True:\\n ret, el = elements.next()\\n if ret == Gst.IteratorResult(1): # GST_ITERATOR_OK\\n _elements.append(el)\\n else:\\n break\\n elements = _elements\\n\\n return [e for e in elements if isinstance(e, cls)]\",\n \"def list(self, *args):\\n return []\",\n \"def get_instances(self):\\n connection = self.connection\\n\\n instances = []\\n\\n connection.row_factory = sqlite3.Row\\n cur = connection.cursor()\\n cur.execute(\\\"SELECT * FROM INSTANCES\\\")\\n rows = cur.fetchall()\\n columns = [str(i[0]).lower() for i in cur.description]\\n for row in rows:\\n object = dict(zip(columns, row))\\n instances.append(object)\\n\\n instancesNoneDict = {}\\n\\n for instance in instances:\\n if instance['harvesterid'] not in instancesNoneDict:\\n instancesNoneDict[instance['harvesterid']] = {}\\n if instance['harvesterhost'] not in instancesNoneDict[instance['harvesterid']]:\\n instancesNoneDict[instance['harvesterid']][instance['harvesterhost']] = {\\n 'availability': instance['availability'], 'errorsdesc': instance['errorsdesc'],\\n 'contacts': instance['contacts'].split(','),\\n 'active': instance['active'], 'notificated': instance['notificated']}\\n elif instance['harvesterid'] in instancesNoneDict:\\n if instance['harvesterhost'] not in instancesNoneDict[instance['harvesterid']]:\\n instancesNoneDict[instance['harvesterid']][instance['harvesterhost']] = {\\n 'availability': instance['availability'], 'errorsdesc': instance['errorsdesc'],\\n 'contacts': instance['contacts'].split(','),\\n 'active': instance['active'], 'notificated': instance['notificated']}\\n if 'none' in instancesNoneDict[instance['harvesterid']]:\\n del instancesNoneDict[instance['harvesterid']]['none']\\n return instancesNoneDict\",\n \"def fetch_instances(self, ids):\\n result = []\\n self.log.info(f\\\"fetch '{len(ids)}' instances\\\")\\n self.log.debug(f\\\"fetch instance data for ids '{ids}'\\\")\\n try:\\n response = self.client.describe_instances(\\n InstanceIds=ids\\n )\\n if 'HTTPStatusCode' in response['ResponseMetadata'] and response['ResponseMetadata']['HTTPStatusCode'] == 200:\\n pass\\n else:\\n raise Exception(f'not able to fetch instacnes with ids: {ids}')\\n if len(response['Reservations'][0]['Instances']) == 0:\\n raise Exception(f'should retrun at least single insatance data')\\n result = []\\n for reservation in response[\\\"Reservations\\\"]:\\n for el in reservation[\\\"Instances\\\"]:\\n ec2 = EC2Instance.factory(el)\\n if ec2.state:\\n result.append(ec2)\\n else:\\n self.log.warn(f'instance \\\"{ec2.id}\\\" excluded')\\n except Exception as e:\\n raise Exception(f'exception when trying to fetch instance data {ids}')\\n return sorted(list(result), key=lambda instance: instance.launch_time)\",\n \"def get_instances_to_forward(self, definition: Definition) -> List[str]:\\n if not definition in self._internal_book:\\n return []\\n return [\\n instance_name\\n for instance_name, definitions in self.book.items()\\n if definition in definitions\\n ]\",\n \"def list_instances(self):\\n LOG.debug(\\\"list_instances\\\")\\n\\n instance_ids = []\\n bmms = db.bmm_get_all(None)\\n for bmm in bmms:\\n if not bmm[\\\"instance_id\\\"]:\\n continue\\n instance_ids.append(self._instance_id_to_name(bmm[\\\"instance_id\\\"]))\\n\\n return instance_ids\",\n \"def getXeprInstances():\\n apilib = _loadapilib()\\n instances = _findInst(apilib)\\n return dict([(p, t) for p, t in instances])\",\n \"def get_all(self):\\n return [_ for _ in self]\",\n \"def getAllCls(cls):\\n newlist = list(clslist)\\n return newlist\",\n \"def get_all(cls):\\n return DataStore.get_all_instance(cls)\",\n \"def list_instances():\\n if request.method == \\\"GET\\\":\\n return render_template(\\\"instances.html\\\")\",\n \"def getList(self):\\n\\treturn self.list\",\n \"def iter(self):\\n return []\",\n \"def get_instances_by_tags(self, tags):\\n return self.get_only_instances(filters={'tag:{}'.format(key): val for key, val in tags.items()})\",\n \"def get_instance_classes():\\n return Base_Instance.instance_classes\",\n \"def list(self):\\n return self.objects.all()\",\n \"def load_from_file(cls):\\n lists = []\\n filename = cls.__name__ + \\\".json\\\"\\n try:\\n with open(filename, \\\"r\\\") as f:\\n instances = cls.from_json_string(f.read())\\n for k, v in enumerate(instances):\\n lists.append(cls.create(**instances[k]))\\n\\n except:\\n pass\\n return lists\",\n \"def lists(self):\\r\\n return Lists(self)\",\n \"def _get_all_records(self) -> List[DBModelInstance]:\\n return self.model.query.all()\",\n \"def get_instance_list():\\n return parse_list_output(Popen('nova list --all-tenants'.split(),\\n stdout=STDOUT, stderr=STDERR).communicate()[0])\",\n \"def find_objs(self, cls, **attr):\\n nodes = getattr(self.graph, getattr(models, cls).element_plural).query(**attr).all()\\n return nodes\",\n \"def obj_list(self):\\n return self._obj_list\",\n \"def all(cls):\\n return []\",\n \"def get_objects(self):\\n return self._objects\",\n \"def get_all(cls):\\n return db_session.query(cls).order_by(cls.name).all()\",\n \"def do_all(self, *args):\\n args = [ele for ele in args[0].split(' ')]\\n print_obj = []\\n storage.reload()\\n if args[0] == '':\\n for key, obj in storage.all().items():\\n print_obj.append(obj.__str__())\\n print(print_obj)\\n return\\n if args[0] not in self.list_classes:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n else:\\n ''' Get a list of specified instances '''\\n for key, obj in storage.all().items():\\n key = key.split('.')\\n if key[0] == args[0]:\\n print_obj.append(obj.__str__())\\n print(print_obj)\",\n \"def get_list(self):\\n return self.__repository.get_all()\",\n \"def create_list(cls, *args):\\n return _create_list(cls, *args)\",\n \"def create_list(cls, *args):\\n return _create_list(cls, *args)\",\n \"def get_records(self) -> List[DBModelInstance]:\\n return self._get_all_records()\",\n \"def __toObjList(self, cursor, className):\\n lst = []\\n for row in cursor.fetchall():\\n # first convert row to a dictionary\\n rowdict={}\\n for idx, col in enumerate(cursor.description):\\n memberName = col[0].strip().replace(' ', '__')\\n rowdict[memberName] = row[idx]\\n # create class of type and set properties to dictionary\\n instance = type(className, (), rowdict)\\n lst.append(instance)\\n return lst\",\n \"def list_instances():\\n js = _get_jetstream_conn()\\n il = js.compute.instances.list()\\n if not il:\\n msg = \\\"You don't have any instances available.\\\"\\n else:\\n msg = (\\\"You have {0} instances available. Here are up to 3 most \\\"\\n \\\"recent: \\\".format(len(il)))\\n msg_ex = \\\"\\\"\\n content = \\\"\\\"\\n for i in il[:3]:\\n msg_ex += \\\"{0},\\\".format(i.name)\\n content += \\\"{0} ({1})\\\\n\\\".format(\\n i.name, i.public_ips[0] if i.public_ips else i.private_ips[0])\\n return statement(msg + msg_ex).simple_card(title=msg, content=content)\",\n \"def _generate_instances(self, single_traj):\\n return [single_traj[:2].values]\",\n \"def instances(self) -> pulumi.Output[Sequence[str]]:\\n return pulumi.get(self, \\\"instances\\\")\",\n \"def get_instances_of_class(cls, folder):\\n data = list()\\n for _, _, filenames in os.walk(folder):\\n for filename in filenames:\\n if filename.endswith(\\\".jpg\\\"):\\n last = filename.split(\\\"/\\\")[-1]\\n if re.match(cls, last):\\n data.append(last)\\n return data\",\n \"def all(cls):\\n return (cls(**client) for client in cls.collection().find({}))\",\n \"def get_instances(self, region):\\n try:\\n conn = ec2.connect_to_region(region, **self.credentials)\\n region_instances = []\\n reservations = conn.get_all_reservations()\\n for reservation in reservations:\\n for instance in reservation.instances:\\n region_instances.append(instance)\\n except boto.exception.EC2ResponseError:\\n return []\\n return region_instances\",\n \"def list_instances(self):\\n instances = []\\n try:\\n pages = self.compute.virtual_machines.list(\\n CONF.azure.resource_group)\\n except Exception as e:\\n msg = six.text_type(e)\\n LOG.exception(msg)\\n ex = exception.InstanceListFailure(reason=six.text_type(e))\\n raise ex\\n else:\\n if pages:\\n for i in pages:\\n instances.append(i.name)\\n return instances\",\n \"def get_elements(self):\\n query = f\\\"select name, middle_name, last_name, age from `{self.table_id}`\\\"\\n query_job = self.client.query(query)\\n clients = []\\n for row in query_job:\\n print('Name', row['name'], 'middle name:', row['middle_name'], 'last name: ',row['last_name'], 'age:', row['age'])\\n clients.append(Client(row['name'],row['middle_name'],row['last_name'],row['age']))\\n return clients\",\n \"def get_list(self, *args, **kwargs):\\n pass\",\n \"def get_list(self, *args, **kwargs):\\n pass\",\n \"def objects(self):\\n\\t\\treturn self._objects\",\n \"def yield_instances(self, instance_filter=None):\\n if instance_filter and set(\\\"\\\\\\\"\\\\\\\\'\\\").intersection(instance_filter):\\n raise ValueError('Invalid instance filter: %s' % instance_filter)\\n page_token = None\\n while True:\\n params = {'maxResults': 250}\\n if instance_filter:\\n params['filter'] = 'name eq \\\"%s\\\"' % instance_filter\\n if page_token:\\n params['pageToken'] = page_token\\n resp = self.call_api('/aggregated/instances', params=params, deadline=120)\\n items = resp.get('items', {})\\n for zone in sorted(items):\\n for instance in items[zone].get('instances', []):\\n yield instance\\n page_token = resp.get('nextPageToken')\\n if not page_token:\\n break\",\n \"def get_activities(cls):\\n objs = cls.objects\\n return objs\",\n \"def __get_multi_instances(self, reservations, instance_ids=None, policies=None):\\n check_instance_ids = False\\n if ( instance_ids and len(instance_ids) > 0 ):\\n check_instance_ids = True\\n instances = [] \\n for reservation in reservations:\\n if check_instance_ids:\\n for instance in reservation.instances:\\n if instance.id in instance_ids:\\n instances.append(instance)\\n elif policies:\\n for instance in reservation.instances:\\n if 'typevm' in policies and instance.instance_type == policies['typevm']:\\n instances.append(instance) \\n elif policies.get('level')==1:\\n if self.__compare_types_instances(policies, instance.instance_type.encode(\\\"latin-1\\\")):\\n instances.append(instance)\\n elif policies.get('level') == 0:\\n if self.__is_adaptive_instance(self.__get_metrics_adapted(policies), instance.instance_type.encode(\\\"latin-1\\\")):\\n instances.append(instance)\\n else:\\n instances=[]\\n else:\\n instances += reservation.instances\\n return instances, len(instances)\",\n \"def list_instances(self, label_filters: Optional[dict] = None) -> List[\\\"GCPNode\\\"]:\\n return\",\n \"def filter(self, cls):\\n return ElementList([x for x in self._elements if isinstance(x, cls)])\",\n \"def _get_instances(instance_tags, region):\\n return ec2_conn[region].get_all_instances(filters={\\\"tag:Name\\\": instance_tags})\",\n \"def all(self):\\n return (self.__objects)\",\n \"def all(cls):\\n api = BuslineAPI()\\n try:\\n objects = api.all()\\n except ApiException:\\n objects = cls.objects.all()\\n return objects\",\n \"def get_instance_essentials(self):\\n ret = []\\n for instance in self.all_instances:\\n ret.append(instance.get_essentials())\\n return ret\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8240453","0.77040386","0.7198313","0.7156317","0.7027863","0.70239186","0.69569033","0.69567513","0.6942843","0.6935414","0.6921797","0.6883705","0.6883301","0.6853721","0.6853102","0.6853102","0.68430334","0.68341786","0.68341786","0.68209326","0.68209326","0.68209326","0.67572856","0.6731012","0.67307985","0.67272395","0.6725228","0.6723615","0.6690422","0.6663551","0.6659956","0.6618242","0.659956","0.65463686","0.65361303","0.65108556","0.6500838","0.648983","0.64503235","0.6439528","0.6438557","0.64376897","0.64269316","0.64265275","0.6424647","0.64195955","0.6413793","0.63974065","0.63938564","0.63875043","0.63868326","0.6385758","0.6377884","0.63727146","0.6370295","0.63668275","0.63639015","0.63613826","0.6358781","0.6354191","0.63439465","0.63256717","0.6312744","0.6309509","0.63087344","0.63066846","0.63034916","0.6293763","0.6284222","0.62757945","0.6271834","0.6265885","0.6262199","0.62345445","0.6233881","0.62277454","0.62119675","0.62026215","0.62026215","0.6200744","0.6194497","0.61877394","0.61715746","0.6170595","0.61702657","0.6165534","0.6161128","0.6157522","0.6150123","0.613875","0.613875","0.61319894","0.6129285","0.6128768","0.61276364","0.6116587","0.6116083","0.61089027","0.6104758","0.6102951","0.61028624"],"string":"[\n \"0.8240453\",\n \"0.77040386\",\n \"0.7198313\",\n \"0.7156317\",\n \"0.7027863\",\n \"0.70239186\",\n \"0.69569033\",\n \"0.69567513\",\n \"0.6942843\",\n \"0.6935414\",\n \"0.6921797\",\n \"0.6883705\",\n \"0.6883301\",\n \"0.6853721\",\n \"0.6853102\",\n \"0.6853102\",\n \"0.68430334\",\n \"0.68341786\",\n \"0.68341786\",\n \"0.68209326\",\n \"0.68209326\",\n \"0.68209326\",\n \"0.67572856\",\n \"0.6731012\",\n \"0.67307985\",\n \"0.67272395\",\n \"0.6725228\",\n \"0.6723615\",\n \"0.6690422\",\n \"0.6663551\",\n \"0.6659956\",\n \"0.6618242\",\n \"0.659956\",\n \"0.65463686\",\n \"0.65361303\",\n \"0.65108556\",\n \"0.6500838\",\n \"0.648983\",\n \"0.64503235\",\n \"0.6439528\",\n \"0.6438557\",\n \"0.64376897\",\n \"0.64269316\",\n \"0.64265275\",\n \"0.6424647\",\n \"0.64195955\",\n \"0.6413793\",\n \"0.63974065\",\n \"0.63938564\",\n \"0.63875043\",\n \"0.63868326\",\n \"0.6385758\",\n \"0.6377884\",\n \"0.63727146\",\n \"0.6370295\",\n \"0.63668275\",\n \"0.63639015\",\n \"0.63613826\",\n \"0.6358781\",\n \"0.6354191\",\n \"0.63439465\",\n \"0.63256717\",\n \"0.6312744\",\n \"0.6309509\",\n \"0.63087344\",\n \"0.63066846\",\n \"0.63034916\",\n \"0.6293763\",\n \"0.6284222\",\n \"0.62757945\",\n \"0.6271834\",\n \"0.6265885\",\n \"0.6262199\",\n \"0.62345445\",\n \"0.6233881\",\n \"0.62277454\",\n \"0.62119675\",\n \"0.62026215\",\n \"0.62026215\",\n \"0.6200744\",\n \"0.6194497\",\n \"0.61877394\",\n \"0.61715746\",\n \"0.6170595\",\n \"0.61702657\",\n \"0.6165534\",\n \"0.6161128\",\n \"0.6157522\",\n \"0.6150123\",\n \"0.613875\",\n \"0.613875\",\n \"0.61319894\",\n \"0.6129285\",\n \"0.6128768\",\n \"0.61276364\",\n \"0.6116587\",\n \"0.6116083\",\n \"0.61089027\",\n \"0.6104758\",\n \"0.6102951\",\n \"0.61028624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":9499,"cells":{"query":{"kind":"string","value":"Method to serialize in csv"},"document":{"kind":"string","value":"def save_to_file_csv(cls, list_objs):\n list_rectangle = [\"id\", \"width\", \"height\", \"x\", \"y\"]\n list_square = [\"id\", \"size\", \"x\", \"y\"]\n filename = cls.__name__ + \".csv\"\n result = []\n\n if list_objs:\n for objs in list_objs:\n # First recollect the info of the object with a dict\n dictionary = objs.to_dictionary()\n middle_result = []\n # Second obtein the values in a ordered class list\n if cls.__name__ == \"Rectangle\":\n for item in list_rectangle:\n middle_result.append(dictionary[item])\n if cls.__name__ == \"Square\":\n for item in list_square:\n middle_result.append(dictionary[item])\n # append the list to result list\n result.append(middle_result)\n with open(filename, \"w\", encoding=\"utf-8\") as file:\n writer = csv.writer(file)\n writer.writerows(result)"},"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_csv_string(self, **kwargs):\n ...","def to_csv(self, csvwriter):\n csvwriter.writerow(self.to_csv_row())","def toCsv(self, csv_path):\n ser = pd.Series(self)\n ser.to_csv(csv_path)","def ToCsv(self):\n\n def csv_helper(the_dict, the_field):\n if the_field not in the_dict:\n return \"\"\n value = the_dict[the_field]\n if value is None:\n return \"\"\n if isinstance(value, set):\n value = \"{}\".format(value)\n #yes, I want to fallback to the previous case\n\n\n if isinstance(value, str):\n value = value.replace(\"\\\"\",\"\\\"\\\"\")\n value = value.replace(\"\\r\",\"\")\n #value = value.replace(\"\\n\",\"\\\\n\")\n return \"\\\"{}\\\"\".format(value)\n return value\n\n output = \"\"\n first = True\n for one_field in self.CSV_FIELDS:\n if first:\n first = False\n template = \"{}{}\"\n else:\n template = \"{},{}\"\n output = template.format(output, csv_helper(self.__dict__, one_field))\n return output","def _CsvFunc(self, obj=None, verbose=False, use_pager=None, to_file=None):\n if obj is not None:\n self._printed_variables.append(obj)\n lines = describe.GenerateLines(obj, verbose=verbose, recursive=False,\n format_name='csv')\n _WriteToStream(lines, use_pager=use_pager, to_file=to_file)","def write_csv(self, filelike):\r\n items = self.rows()\r\n writer = unicodecsv.writer(filelike, encoding=\"utf-8\")\r\n writer.writerow(self.header())\r\n for item in items:\r\n writer.writerow(item)","def to_csv_file_obj(self, rows):\n output = StringIO.StringIO()\n writer = csv.writer(output)\n writer.writerows(rows)\n return output","def save_csv(self, filename): # DONE\n self.data.to_csv(filename)","def __create_csv(self):\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\n writer.writeheader()","def to_csv(self, save_folder: Path) -> None:\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\n serializer.dump(instance=self, folder_path=save_folder)","def store_csv(self):\n\n with open(self.filepath.with_suffix(\".csv\"), 'w',\n newline='') as csvfile:\n fieldnames = ['counter', 'timestamp', 'acceleration']\n writer = DictWriter(csvfile, fieldnames=fieldnames)\n\n writer.writeheader()\n writer.writerows(self.values)","def _serialize_row(self, data):\n if isinstance(data, str):\n return data\n\n if isinstance(data, np.ndarray):\n data = np.ndarray.flatten(data)\n\n if hasattr(data, \"__len__\"):\n if len(data) == 0:\n raise ValueError(\"Cannot serialize empty array\")\n csv_buffer = io.StringIO()\n csv_writer = csv.writer(csv_buffer, delimiter=\",\")\n csv_writer.writerow(data)\n return csv_buffer.getvalue().rstrip(\"\\r\\n\")\n\n raise ValueError(\"Unable to handle input format: %s\" % type(data))","def save_csv(self):\n if not self.__is_csv():\n # creates the csv file if it did not exist.\n self.__create_csv()\n try:\n with open(self.__csv_file_name, 'a', newline='', encoding='utf-8') as csv_file:\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\n writer.writerow(self.__values)\n except IOError: # this exception avoid a product does not have saved in csv file\n time.sleep(0.5)\n self.save_csv()\n # display on the screen what is being record on csv\n for key, value in self.__values.items():\n print('{}: {}'.format(key, value), end='; ' if key != 'url' else '\\n')","def writeToCSV(self, filepath):\r\n\t\twith open(filepath, 'w') as outputFile:\r\n\t\t\toutputFile.write(str(self))","def _write_csv(self):\n\n # add the label to the header\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self.header.append('Date')\n else:\n self.header.append('sample id')\n\n key_list = []\n\n for i, cube in enumerate(self.cube_list):\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self._write_sample_with_date(cube, i, key_list)\n else:\n self._write_sample(cube, i, key_list)\n\n output_data_file_path = self._get_full_file_name()\n self._write_data_dict(output_data_file_path, key_list)\n\n return [output_data_file_path]","def csv(self, section=\"main\", column_headers=True):\n table_end = \"\\r\\n\\r\\n\\r\\n\"\n table_head_pos = self.header_dictionary[section]\n table_end_pos = self.raw_data[table_head_pos:].find(table_end)\n if table_end_pos == -1:\n table_end_pos = len(self.raw_data)\n else:\n table_end_pos += table_head_pos\n if column_headers:\n a = \",\".join(self.columns()) + \"\\n\"\n else:\n a = \"\"\n return a + self.raw_data[table_head_pos:table_end_pos].replace(\"\\t\",\",\").replace(\"\\r\",\"\")","def get_csv_string(self):\n df = None\n for d in self.data:\n if df is None:\n df = d.as_dataframe()\n else:\n df = df.append(d.as_dataframe())\n\n if df is None:\n return \"\"\n else:\n return df.to_csv(index=False)","def write(self, file: IO) -> None:\n serializer = self.serializer_class(self.get_queryset(), many=True)\n\n writer = csv.DictWriter(file, self.serializer_class.Meta.fields)\n writer.writeheader()\n\n # Write serializer data and replace None/'' with 'NA'\n writer.writerows(\n OrderedDict(\n (\n field_name,\n \"NA\" if (field_value is None or field_value == \"\") else field_value,\n )\n for field_name, field_value in row.items()\n )\n for row in serializer.data\n )\n\n file.seek(0)","def serialize(self, data):\n if hasattr(data, \"read\"):\n return data.read()\n\n if isinstance(data, DataFrame):\n return data.to_csv(header=False, index=False)\n\n is_mutable_sequence_like = self._is_sequence_like(data) and hasattr(data, \"__setitem__\")\n has_multiple_rows = len(data) > 0 and self._is_sequence_like(data[0])\n\n if is_mutable_sequence_like and has_multiple_rows:\n return \"\\n\".join([self._serialize_row(row) for row in data])\n\n return self._serialize_row(data)","def export_csv(header, data):\n with StringIO() as tmp:\n writer = csv.DictWriter(tmp, fieldnames=header)\n writer.writeheader()\n writer.writerows(data)\n data = tmp.getvalue()\n\n return data","def save_csv(self, filename: str, type='n', **args):\n if type == 'n':\n df = self.export_nodes()\n else:\n df = self.export_edges()\n df.to_csv(filename, index=False)","def save_csv(self):\n path, _ = QtWidgets.QFileDialog.getSaveFileName(self, '保存数据', '', 'CSV(*.csv)')\n\n if not path:\n return\n\n with open(path, 'w') as f:\n writer = csv.writer(f, lineterminator='\\n')\n\n writer.writerow(self.headers.keys())\n\n for row in range(self.rowCount()):\n row_data = []\n for column in range(self.columnCount()):\n item = self.item(row, column)\n if item:\n row_data.append(str(item.text()))\n else:\n row_data.append('')\n writer.writerow(row_data)","def to_csv(self, filename, **kwargs):\n self.data.to_csv(filename, **kwargs)","def _csv_export(self, exppath):\n with open(exppath, 'w') as csvfile:\n csvwriter = csv.writer(csvfile, delimiter=',', skipinitialspace=True)\n csvwriter.writerow(['hexstr','dmc','name'])\n for clr in self.lookup_table:\n csvwriter.writerow([clr.hex.to_str(), clr.id, clr.name])","def queryset_to_csv(self):\n csv_data = []\n custom_fields = []\n\n # Start with the column headers\n headers = self.queryset.model.csv_headers.copy()\n\n # Add custom field headers, if any\n if hasattr(self.queryset.model, 'get_custom_fields'):\n for custom_field in self.queryset.model().get_custom_fields():\n headers.append(custom_field.name)\n custom_fields.append(custom_field.name)\n\n csv_data.append(','.join(headers))\n\n # Iterate through the queryset appending each object\n for obj in self.queryset:\n data = obj.to_csv()\n\n for custom_field in custom_fields:\n data += (obj.cf.get(custom_field, ''),)\n\n csv_data.append(csv_format(data))\n\n return '\\n'.join(csv_data)","def DumpCsv(data):\n \n raise Exception('TBI: Need standard container structure for this to work, cause its flat...')","def read_csv():","def create_csv_file(self):\r\n # Create a new csv-file\r\n with open(self.fname, 'w') as f:\r\n writer = csv.writer(f, dialect='excel')\r\n writer.writerow(['set_time',\r\n 'read_time_P_ac',\r\n 'read_time_P_bat',\r\n 'soc',\r\n 'set_value',\r\n 'P_ac',\r\n 'P_bat'])","def csv_content(self):\n if not hasattr(self, 'CSV_COLUMNS'):\n raise NotImplementedError('Child classes of CsvForm must implement the CSV_COLUMNS constant')\n\n # Get column fields and headers\n csv_columns = [i['column'] for i in self.CSV_COLUMNS]\n csv_headers = [i['title'].encode('utf-8') for i in self.CSV_COLUMNS]\n\n # Build data for csv writer\n csv_data = []\n for obj in self.get_queryset():\n csv_data.append([unicode(csv_getvalue(obj, column)).encode('utf-8') for column in csv_columns])\n\n # Create buffer with csv content\n content = StringIO()\n writer = csv.writer(content)\n writer.writerow(csv_headers)\n writer.writerows(csv_data)\n content.seek(0)\n\n return content","def csv(self):\n return '{:.6f},{:.6f},{},{}'.format(\n self.sample_time, self.value_time, self.value, self.status)","def write_to_file(data, method, delimiter):\r\n output_file = 'data.csv'\r\n with open(output_file, method, newline='', encoding='utf-8') as file:\r\n writer = csv.writer(file, delimiter=delimiter)\r\n writer.writerows([data])","def generate_csv_file(rows: Collection[dict[str, str]]):\n file = io.StringIO()\n csv_writer = csv.DictWriter(file, (\"label\", \"inventory\", \"collection\"))\n csv_writer.writeheader()\n csv_writer.writerows(rows)\n file.seek(0)\n return io.BytesIO(bytes(file.read(), encoding=\"utf-8\"))","def to_csv(self, filename):\n self.data.to_csv(filename)","def to_csv(self, filename):\n self.data.to_csv(filename)","def csv(self):\n return '{:.6f},{},{}'.format(self.sample_time, self.value, self.status)","def _csv(content):\n response = _data_frame(content).to_csv(index=False)\n return response","def _csvWriter(self):\r\n # Initialize Header\r\n table = []\r\n voltageRow = []\r\n for i in range(len(self._voltages)):\r\n voltageRow.append(self._voltages[i][0])\r\n voltageRow.append(\" \")\r\n if self._vna.isTwoComponents():\r\n voltageRow.append(\" \")\r\n table.append(voltageRow)\r\n \r\n # Fill table with data\r\n # if self._vna.isTwoComponents():\r\n # for i in range(len(self._frequency[0])):\r\n # row = []\r\n # for j in range(len(self._frequency)):\r\n # row.append(self._frequency[j][i])\r\n # row.append(self._intensity[j][2*i])\r\n # row.append(self._intensity[j][2*i + 1])\r\n # table.append(row)\r\n # else: \r\n for i in range(len(self._frequency[0])):\r\n row = []\r\n for j in range(len(self._frequency)):\r\n row.append(self._frequency[j][i])\r\n row.append(self._intensity[j][i])\r\n table.append(row)\r\n\r\n # Write to CSV\r\n filename = 'CSVs/' + self._vna.getDateFormatted() + '.csv'\r\n with open(filename, 'w', newline='') as csvfile:\r\n dataWriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)\r\n for i in range(len(table)):\r\n dataWriter.writerow(table[i])","def as_csv(obj, f):\n val = getattr(obj, f)\n if sys.version_info >= (3, 0) and type(val) is bytes:\n return val.decode()\n return val","def exportCSV(self, log, csvFile):\n return 0","def setup_csv(self) -> None:\n csvData = ['Followers', 'Time']\n\n # Create our CSV file header\n with open(self.graphfile, 'w') as csvFile:\n writer = csv.writer(csvFile)\n writer.writerow(csvData)\n csvFile.close()","def __init__(self, content_type=\"text/csv\"):\n super(CSVSerializer, self).__init__(content_type=content_type)","def generateCsvData(self, context, obj, entity):\n raise NotImplementedError()","def csv_output(self):\r\n fh = open(\"output.csv\",'w')\r\n for i in range(len(self.population.columns)):\r\n if i != len(self.population.columns)-1:\r\n fh.write(str(self.population.columns[i]))\r\n fh.write(\",\")\r\n else:\r\n fh.write(str(self.population.columns[i]))\r\n fh.write(\"\\n\")\r\n\r\n for i in range(len(self.population.data)):\r\n for j in range(len(self.population.data[i])):\r\n if j != len(self.population.data[i])-1:\r\n fh.write(str(self.population.data[i][j]))\r\n fh.write(\",\")\r\n else:\r\n fh.write(str(self.population.data[i][j]))\r\n fh.write(\"\\n\")\r\n fh.close()","def export_to_csv(self, request, queryset):\n fields = self.get_table_fields()\n field_names = [field.name for field in fields]\n field_verbose_names = [field.verbose_name.encode(\n 'utf-8'\n ) for field in fields]\n\n response = HttpResponse(content_type='text/csv')\n response['Content-Disposition'] = 'attachment; \\\nfilename=%s.csv' % unicode(self.model._meta).replace('.', '_')\n\n writer = csv.writer(response)\n writer.writerow(field_verbose_names)\n for obj in queryset:\n writer.writerow([unicode(getattr(obj, field)).encode(\n \"utf-8\",\n \"replace\"\n ) for field in field_names])\n return response","def CSVstr(self):\n return self.start.CSVstr() + ',' + self.end.CSVstr()","def CSVLine(self):\n \t\n l = []\n for k in sorted(Statistics.attrs.keys()):\n l.append(self.__dict__[k])\n\n return ','.join(str(i) for i in l)","def csv_writer(data, path):\n\twith open(path, \"wb\") as csv_file:\n\t\twriter= csv.writer(csv_file, delimiter=',')\n\t\twriter.writerows(data)","def to_csv(self, dataset):\n save_as = filedialog.asksaveasfilename(defaultextension='.csv')\n try:\n with open(save_as, 'w', newline='') as file:\n scribe = csv.writer(file)\n scribe.writerow(HEADERS)\n for row in dataset:\n scribe.writerow(row.values())\n self.info_success(save_as)\n except IOError:\n self.info_error()\n return","def writeCSV(filename, separator, data):\n \n filetowrite = open(filename, \"w\")\n values = []\n i = 0 #Count the number of objects already written\n for item in data:\n filetowrite.write(item)\n i += 1\n if i < len(data.keys()):\n filetowrite.write(separator)\n values.append(data[item])\n filetowrite.write(\"\\n\")\n i = 0\n for value in values:\n filetowrite.write(str(value))\n i += 1\n if i < len(values):\n filetowrite.write(separator)\n \n filetowrite.close()","def csv_file(data,output_dir,filename,order = [],head = True):\n with open(output_dir + filename + '.csv', 'w') as f:\n write = csv.writer(f)\n write.writerows(manip.dic_to_list(data,order,head),)\n return None","def export_csv(self, path):\r\n\r\n with open(path, 'w') as f:\r\n f.write('# h,hr,m')\r\n\r\n if self.rho is not None:\r\n f.write(',rho')\r\n if self.temperature is not None:\r\n f.write(',temperature')\r\n\r\n f.write('\\n')\r\n for i in range(self.shape[0]):\r\n for j in range(self.shape[1]):\r\n f.write(f'{self.h[i, j]},{self.hr[i, j]},{self.m[i, j]}')\r\n if self.rho is not None:\r\n f.write(f',{self.rho[i, j]}')\r\n if self.temperature is not None:\r\n f.write(f',{self.temperature[i, j]}')\r\n f.write('\\n')\r\n return","def csv(self, destination_path):\n # todo - test for single and duplicate base cases\n to_csv(self._axl_data, destination_path)","def to_csv(self, filename, **csv_args):\n dataframe = pd.DataFrame.from_dict(self.to_dict())\n return dataframe.to_csv(filename, **csv_args)","def csv_data():\r\n for row in data:\r\n writer.writerow(row)\r\n csv_data = read_and_flush()\r\n yield csv_data","def __open_csv(self):\n self.__csv_file = open(self.__csv_file_name, 'w', encoding='utf-8')\n self.__csv_writer = csv.writer(self.__csv_file, delimiter=',', )","def to_csv(val):\n # Make sure all individual values do not contain\n # leading or trailing whitespaces.\n unicode_values = list(map(str.strip, map(str, val)))\n stream = StringIO()\n writer = csv.writer(stream, dialect=\"excel\")\n writer.writerow(unicode_values)\n # Strip any csv.writer added carriage return line feeds\n # and double quotes before saving.\n csv_string = stream.getvalue().strip().strip('\"')\n if len(unicode_values) > 1:\n csv_string = \"[\" + csv_string + \"]\"\n return csv_string","def write_csv(self, file):\n # Write header row\n file.write('Timestamp,MessageType,Queue,Price,Volume,OrderID\\n')\n # Write content\n for x in self.records:\n row = (str(x[0]) + ',' + x[1][\"MessageType\"] + ',' +\n x[1][\"Queue\"] + ',' + str(x[1][\"Price\"]) + ',' +\n str(x[1][\"Volume\"]) + ',' + str(x[1][\"OrderID\"]) + '\\n')\n file.write(row)","def save_to_file_csv(cls, list_objs):\n l = []\n if list_objs is not None:\n for item in list_objs:\n l.append(item.to_dictionary())\n with open(\"%s.csv\" % cls.__name__, mode='w') as f:\n f.write(Base.to_json_string(l))","def to_csv(self, csv_path) -> None:\n families = []\n for row in self.rows:\n row.assign_seats()\n families += row.families\n families.sort(key=lambda f: f.name)\n\n with open(csv_path, mode='w') as f:\n writer = csv.writer(f)\n writer.writerow(['Family Name', 'Seats'])\n for fam in families:\n writer.writerow([fam.name, *fam.seats])","def generate_csv(inf, outf):\n o = csv.writer(outf)\n o.writerow(COLUMNS)\n for row in reformat_data(inf):\n o.writerow([inf.name] + row)","def writetoCSV(self, fileName):\n\n with open(fileName, 'w') as writeFile:\n writeFile.write(\"ID,Fx,Fy,Fz\\n\")\n for fstnr in F:\n writeFile.write(str(fstnr.ID))\n for i in fstnr.force:\n writeFile.write(',' + str(i))\n writeFile.write('\\n')","def saveCsv(self, filePath = None, rowDeliminator = None, columnDeliminator = None, sheetDeliminator = None, yieldForNone = \"\", skipLineCondition = None):\n\n\t\t\tdef yieldValues(row):\n\t\t\t\tfor cell in row:\n\t\t\t\t\tvalue = cell.value\n\t\t\t\t\tif (value is None):\n\t\t\t\t\t\tyield yieldForNone\n\t\t\t\t\telse:\n\t\t\t\t\t\tyield value\n\n\t\t\tif (skipLineCondition is None):\n\t\t\t\tdef yieldRows(mySheet):\n\t\t\t\t\tfor row in mySheet.thing.rows:\n\t\t\t\t\t\tyield rowDeliminator.join(yieldValues(row))\n\t\t\telse:\n\t\t\t\tdef yieldRows(mySheet):\n\t\t\t\t\tfor row in mySheet.thing.rows:\n\t\t\t\t\t\tif (not skipLineCondition(row)):\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tyield rowDeliminator.join(yieldValues(row))\n\n\t\t\tdef yieldSheet():\n\t\t\t\tnonlocal self\n\n\t\t\t\tfor mySheet in self:\n\t\t\t\t\tyield columnDeliminator.join(yieldRows(mySheet))\n\n\t\t\t############################\n\n\t\t\trowDeliminator = self.ensure_default(rowDeliminator, \",\")\n\t\t\tsheetDeliminator = self.ensure_default(sheetDeliminator, \"\\n\")\n\t\t\tcolumnDeliminator = self.ensure_default(columnDeliminator, \"\\n\")\n\n\t\t\t_filePath = self.ensure_filePath(self.ensure_default(filePath, default = self.filePath), ending = (\".csv\"), checkExists = False)\n\t\t\twith open(_filePath, \"w+\") as fileHandle:\n\t\t\t\tfileHandle.write(sheetDeliminator.join(yieldSheet()))","def save(self, path, separator=\",\", encoder=lambda j,v: v):\n # csv.writer will handle str, int, float and bool:\n s = StringIO()\n w = csv.writer(s, delimiter=separator)\n w.writerows([[encode_utf8(encoder(j,v)) for j,v in enumerate(row)] for row in self])\n f = open(path, \"wb\")\n f.write(BOM_UTF8)\n f.write(s.getvalue())\n f.close()","def csv_export(self,\n states=None,\n fields=None,\n filenamebase='projects',\n delimiter=',',\n newline='\\r\\n',\n ):\n \n if fields is None:\n fields = self.fields()\n \n out = StringIO()\n out.write(delimiter.join(fields) + newline)\n\n for project in self.data():\n values = []\n for field in project:\n text = field['text']\n if type(text) is UnicodeType:\n text = text.encode('utf8')\n value = CSV_TEMPLATE % text\n values.append(value)\n out.write(delimiter.join(values) + newline)\n \n value = out.getvalue()\n out.close()\n\n timestamp = datetime.today().strftime(\"%Y%m%d%H%M\")\n filename = filenamebase + timestamp + '.csv'\n \n self.request.RESPONSE.setHeader('Content-Type', 'application/x-msexcel')\n self.request.RESPONSE.setHeader(\"Content-Disposition\", \n \"inline;filename=%s\"%filename)\n\n return value","def get_csv_line(self):\n return \"{},{},{},{},{},{},{}\\n\".format(self.employee_id, self.gender,\n self.sales, self.bmi,\n self.salary,\n self.get_birthday_string(),\n self.age)","def serialize(self, pid, record, links_factory=None):\n record = self.process_dict(self.transform_record(pid, record, links_factory))\n\n return self._format_csv([record])","def file(self):\n result = []\n completePath = CompletePath(self.path, self.filename) \n with open(completePath.path(), 'w', newline='') as csvfile:\n fieldnames = ['Activity', 'Points']\n writer = csv.DictWriter(csvfile, fieldnames = fieldnames)\n writer.writeheader()\n for i in range ( len( self.groupPriority.rows() ) ):\n tmp = self.groupPriority.rows()[i]\n self.log.info ( \"FinalCSV\", \"file\",\"data {0},{1}\".format( tmp.activity(), tmp.points() ) )\n writer.writerow({'Activity': tmp.activity(), 'Points': tmp.points()})\n self.log.info(\"FinalCSV\", \"file\", \"Elaborated file: {0}\".format ( completePath.path() ) )","def gen_csv(self, show_headers=True, show_tags=True):\n class TextOut:\n \"\"\"Simple string output source to capture CSV\"\"\"\n def __init__(self):\n self.data = ''\n def write(self, s):\n self.data += s\n def get(self):\n data = self.data\n self.data = ''\n return data\n output = TextOut()\n writer = csv.writer(output)\n for raw in self.gen_raw(show_headers, show_tags):\n writer.writerow(raw)\n yield output.get()","def save_csv(data): \n bank_data = data\n\n #Creating headers for the csv file\n header = [\"Lender\", \"Max Loan Amount\", \"Max LTV\", \"Max DTI\", \"Max Credit Score\", \"Interest Rate\"]\n\n #Creating output path of the CSV file\n csvpath = Path(\"save_file.csv\")\n\n #Opening the csv file in csvpath by using the open() method\n with open(csvpath, \"w\", newline='') as csvfile:\n\n csvwriter = csv.writer(csvfile, delimiter = \",\")\n csvwriter.writerow(header)\n for row in bank_data:\n csvwriter.writerow(row)\n\n return data","def csv_write (data):\n \n csv_data=data[0:]\n csv1_data = open('backup.csv', 'a')\n csvwriter = csv.writer(csv1_data)\n\n count = 0\n\n for i in csv_data:\n if count == 0:\n header = i.keys()\n csvwriter.writerow(header)\n count += 1\n csvwriter.writerow(i.values())\n\n csv1_data.close()\n\n #http://blog.appliedinformaticsinc.com/how-to-parse-and-convert-json-to-csv-using-python/","def save_to_csv(self):\r\n # Save the read values to a csv file\r\n with open(self.fname, \"a\") as f:\r\n wr = csv.writer(f, dialect='excel')\r\n wr.writerow([self.set_time, self.read_time_P_ac, self.read_time_P_bat,\r\n self.soc0, self.set_val, self.P_ac, self.P_bat])","def encode_csv(self, dt, ss_code, ss_config, blank, bin_size):\r\n str_result = []\r\n\r\n for beam in range(self.element_multiplier):\r\n for bin_num in range(self.num_elements):\r\n # Get the value\r\n val = self.Amplitude[bin_num][beam]\r\n\r\n # Create the CSV string\r\n str_result.append(Ensemble.gen_csv_line(dt, Ensemble.CSV_AMP, ss_code, ss_config, bin_num, beam, blank, bin_size, val))\r\n\r\n return str_result","def to_csv(header, rows):\r\n with open('result.csv', 'w') as result:\r\n result_writer = csv.writer(result, delimiter=';')\r\n result_writer.writerow(header)\r\n result_writer.writerows(rows)","def write_csv(fn, toCSV):\n keys = toCSV[0].keys()\n with open(fn, 'w') as output_file:\n dict_writer = csv.DictWriter(output_file, keys)\n dict_writer.writeheader()\n dict_writer.writerows(toCSV)","def generate_dataset_csv(request):\n\n response = csv_export(request,Dataset)\n return response","def to_csv(self, file_path: str) -> None:\n with open(file_path, \"w\") as f:\n writer = csv.writer(f)\n writer.writerow([\"parameter\", \"value\"])\n writer.writerow([\"render\", str(self.render)])\n writer.writerow([\"sleep\", str(self.sleep)])\n writer.writerow([\"log_frequency\", str(self.log_frequency)])\n writer.writerow([\"video\", str(self.video)])\n writer.writerow([\"video_fps\", str(self.video_fps)])\n writer.writerow([\"video_dir\", str(self.video_dir)])\n writer.writerow([\"num_episodes\", str(self.num_episodes)])\n writer.writerow([\"gifs\", str(self.gifs)])\n writer.writerow([\"gifdir\", str(self.gif_dir)])\n writer.writerow([\"video_frequency\", str(self.video_frequency)])","def csv(filepath, header=True, mode=DataSaver.MODE_OVERWRITE, sep=',',\n na_rep='', float_format=None, columns=None, encoding=None,\n quoting=None, quotechar='\"', date_format=None, doublequote=True,\n escapechar=None, decimal='.'):\n\n format_file = DataSaver.FORMAT_CSV\n kwargs = locals()\n _apply_datasaver(format_file, kwargs, last_uuid)\n return None","def export_csv(self):\n outputfile = tkinter.filedialog.asksaveasfilename(\n defaultextension=\".csv\",\n filetypes=((\"comma seperated values\", \"*.csv\"),\n (\"All Files\", \"*.*\")))\n if outputfile:\n tabledata = self.tabs.window.aistracker.create_table_data()\n export.write_csv_file(tabledata, outputfile)\n else:\n raise ExportAborted('Export cancelled by user.')","def dump_csv(f, rra, out):\n w = writer(out)\n for row in dump(f, rra):\n w.writerow([s.strip() for s in row])","def _getCSVForPerField(self, statistic):\n\n rows = []\n\n chart_json = simplejson.loads(statistic.chart_json)\n description = chart_json['description'] \n header = []\n for item in description:\n header.append(item[-1].encode('utf-8'))\n rows.append(header)\n\n final_stat = simplejson.loads(statistic.final_json)\n for choice, result in final_stat.iteritems():\n row = []\n row.append(unicode(choice).encode('utf-8'))\n for item in result:\n row.append(unicode(item).encode('utf-8'))\n rows.append(row)\n\n return rows","def csv_writer(data, path):\n\n with open(path, \"a\") as csv_file:\n\n writer = csv.writer(csv_file,delimiter=',')\n\n \n\n writer.writerow(data)","def prepare_CSV(self):\n self.drop_columns()\n self.rename_columns()\n self.spilt_columns()\n self.add_vehicle_id_column()\n self.add_source_column()\n self.add_timestamp_columns()\n self.get_colour_columns()\n self.clean_column_formats()\n\n # print(self.data.info())\n # print(self.data.sample(10))\n\n return self.data","def exportcsvsumdata(self, log):\r\n csvdata= None\r\n\r\n if (log):\r\n csvdata = ('%s\\t'%(log['CALLSIGN']))\r\n csvdata += ('%s\\t'%(log['OPERATORS']))\r\n csvdata += ('%s\\t'%(log['LOCATION']))\r\n csvdata += ('%d\\t'%(log['COUNT']))\r\n csvdata += ('%s\\t'%(log['NAMES']))\r\n if(log['LASTWORKED']): \r\n csvdata += ('%s/%s UTC'%(log['LASTWORKED'],\r\n log['LWTIME'])) \r\n\r\n return csvdata","def save_to_file_csv(cls, list_objs):\n list_dictionaries = []\n if list_objs is None or list_objs == []:\n string_dictionary = \"[]\"\n else:\n for _obj_dict in list_objs:\n list_dictionaries.append(_obj_dict.to_dictionary())\n string_dictionary = Base.to_json_string(list_dictionaries)\n with open(cls.__name__ + \".csv\", \"w\") as _file:\n _file.write(string_dictionary)\n _file.close()","def toCsvStrings(self) -> List[str]:\n return [str(self.getId()),\n str(self.getLeftNode().getId()),\n str(self.getRightNode().getId()),\n CsvWriter.shortenDecimalValueForOutput(self.getLength()),\n str(self.getLowerBound()),\n str(self.getUpperBound())]","def save_csv(filename, rows):\n with open(filename, 'w', newline='', encoding='utf-8') as f:\n writer = csv.writer(f)\n writer.writerow([\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\n 'actor(s)', 'rating(s)', 'number of rating(s)'\n ])\n\n writer.writerows(rows)","def return_csv(func, datatable, file_pointer=None):\r\n if file_pointer is None:\r\n response = HttpResponse(mimetype='text/csv')\r\n response['Content-Disposition'] = 'attachment; filename={0}'.format(func)\r\n else:\r\n response = file_pointer\r\n writer = csv.writer(response, dialect='excel', quotechar='\"', quoting=csv.QUOTE_ALL)\r\n encoded_row = [unicode(s).encode('utf-8') for s in datatable['header']]\r\n writer.writerow(encoded_row)\r\n for datarow in datatable['data']:\r\n # 's' here may be an integer, float (eg score) or string (eg student name)\r\n encoded_row = [\r\n # If s is already a UTF-8 string, trying to make a unicode\r\n # object out of it will fail unless we pass in an encoding to\r\n # the constructor. But we can't do that across the board,\r\n # because s is often a numeric type. So just do this.\r\n s if isinstance(s, str) else unicode(s).encode('utf-8')\r\n for s in datarow\r\n ]\r\n writer.writerow(encoded_row)\r\n return response","def csv_pickle():\n data_dire = 'data'\n requests_csv = os.path.join(data_dire, 'requests.csv')\n supply_csv = os.path.join(data_dire, 'supply.csv')\n transport_csv = os.path.join(data_dire, 'transport.csv')\n\n tc = TransicationRecord.from_csv(supply_csv, requests_csv)\n tp = TransportRecord.from_csv(transport_csv)\n\n Record.to_pickled(os.path.join(data_dire, 'transication.bin'), tc)\n Record.to_pickled(os.path.join(data_dire, 'transport.bin'), tp)","def csvprint(self, data):\n import csv\n import sys\n # self._assert(data) CSV data row lenght can vary\n data = self._render(data) # make elements ascii\n writer = csv.writer(sys.stdout, delimiter=',',\n quotechar='\"', \n quoting=csv.QUOTE_MINIMAL,\n lineterminator=\"\\n\")\n for row in data: writer.writerow(row)","def to_csv(parameters: List['Parameter'], filename: str):\n lines = [parameters[0].keys()]\n for parameter in parameters:\n lines.append(Parameter.to_strs(parameter.values()))\n FileUtiles.csvSave(filename, lines)","def to_csv_line(*args):\r\n return ','.join([str(value) for value in args]) + '\\n'","def export_csv(self, csvfileobject):\n for index, track in enumerate(self._tracks):\n csvfileobject.writerow(track.properties)\n for delta in track.periods: \n csvfileobject.writerow(delta.properties)","def export_as_csv(modeladmin, request, queryset):\n if not request.user.is_staff:\n raise PermissionDenied\n opts = modeladmin.model._meta\n response = HttpResponse(mimetype='text/csv')\n response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(opts).replace('.', '_')\n writer = csv.writer(response, delimiter=';')\n field_names = [field.name for field in opts.fields]\n # Write a first row with header information\n writer.writerow(field_names)\n # Write data rows\n for obj in queryset:\n values = []\n for field in field_names:\n value = (getattr(obj, field))\n if callable(value):\n try:\n value = value() or ''\n except:\n value = 'Error retrieving value'\n if value is None:\n value = ''\n values.append(unicode(value).encode('utf-8'))\n writer.writerow(values)\n #writer.writerow([getattr(obj, field) for field in field_names])\n return response","def write_csv(fhandle, outages, fields):\n writer = csv.DictWriter(fhandle, fields)\n writer.writeheader()\n writer.writerows([o.for_json() for o in outages])","def exportCSV(self, fields=None, coding=None, delimiter='semicolon'):\n\n result = self.generateCSV(fields=fields, delimiter=delimiter)\n\n # encode the result\n charset = self._site_encoding()\n if coding:\n result = result.decode(charset).encode(coding)\n else:\n coding = charset\n\n # set headers and return\n setheader = self.request.RESPONSE.setHeader\n setheader('Content-Length', len(result))\n setheader('Content-Type',\n 'text/x-comma-separated-values; charset=%s' % coding)\n setheader('Content-Disposition',\n 'attachment; filename=%s.csv' % self.context.getId())\n return result","def _export_csv(x, y, export_to):\r\n\r\n with open(export_to, 'w', newline='') as e:\r\n writer = csv.writer(e, delimiter=',')\r\n for i in range (0, len(x)):\r\n writer.writerow([x[i], y[i]])","def to_csv_files(self, path):\n self._to_dict_tree().to_csv_files(path)","def getCsvData(self):\n return [View.getTableHead()] + self.getTableData()","def to_csv(self, path=None, sep=',', data_format=DataFormat.RAW, csv_dialect='excel'):\n\n if path is None:\n file_handle = StringIO()\n self._write_csv(file_handle, csv_dialect, sep, data_format)\n return file_handle.getvalue()\n\n # Path provided\n with open(path, 'w') as file_handle:\n self._write_csv(file_handle, csv_dialect, sep, data_format)","def saveCSV(self):\n filename=tkFileDialog.asksaveasfilename(defaultextension='.csv',\n initialdir=os.getcwd(),\n filetypes=[(\"csv\",\"*.csv\"),(\"All files\",\"*.*\")])\n if not filename:\n return\n for m in self.matrices:\n matrix = self.matrices[m] \n if matrix != None: \n c=matrix.csvRepresentation()\n f=open(filename,'w')\n f.write(c)\n f.close()\n return","def write_to_csv(self, name_suffix = ''):\n f_path = os.path.join(self.root_dir, 'res' + name_suffix + '.csv')\n field_names = [] # the first field in CSV is 'obj_val'\n\n # put the keys in the cost, prim_var_change, dual_var_change and fea_conditions as field names if any\n for key in self.cost.keys():\n field_names.append(key)\n for key in self.cost_change.keys():\n field_names.append(key)\n for key in self.prim_var_change.keys():\n field_names.append(key)\n for key in self.dual_var_change.keys():\n field_names.append(key)\n for key in self.fea_conditions.keys():\n field_names.append(key)\n\n\tprint f_path\n\n with open(f_path, mode = 'wb') as csv_file: # open the file, if not exist, create it\n writer = csv.DictWriter(csv_file, fieldnames = field_names) # create a writer which maps the dictionaries onto output rows in CSV\n writer.writeheader() # write the field names to the header\n temp_dict = {} # create a temporary dict used to output rows\n row_max = self.get_iter_num() # get the max iters which indicates the number of rows in CSV\n print ('number of rows: ' + str(row_max))\n #print (field_names)\n for row in range(row_max + 1):\n temp_dict.clear() # clear all items\n start_idx = 0\n for i in range(len(self.cost)):\n field = field_names[start_idx + i]\n\t\t if row > len(self.cost[field]) - 1:\n\t\t\ttemp_dict[field] = ''\n\t\t else: temp_dict[field] = self.get_cost_val(field, row)\n\n start_idx = start_idx + len(self.cost) # the start pos of fields in field_names for prim_var_change\n for i in range(len(self.cost_change)): # for each cost_change\n field = field_names[start_idx + i]\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of primal variables\n temp_dict[field] = '/'\n elif row > len(self.cost_change[field]) - 1:\n\t\t\t temp_dict[field] = ''\n\t\t else:\n temp_dict[field] = self.get_cost_change_value(field, row - 1)\n\n\n start_idx = start_idx + len(self.cost_change)\n for i in range(len(self.prim_var_change)): # for each prim_var_change\n field = field_names[start_idx + i]\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of primal variables\n temp_dict[field] = '/'\n\t\t elif row > len(self.prim_var_change[field]) - 1:\n\t\t\ttemp_dict[field] = ''\n else:\n temp_dict[field] = self.get_prim_change_value(field, row - 1)\n\n start_idx = start_idx + len(self.prim_var_change) # go to the start pos of fields in field_names for dual_var_change\n for i in range(len(self.dual_var_change)): # for each dual_var_change\n field = field_names[start_idx + i]\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of dual variables\n temp_dict[field] = '/'\n elif row > len(self.dual_var_change[field]) - 1:\n\t\t\ttemp_dict[field] = '' \n\t\t else:\n temp_dict[field] = self.get_dual_change_value(field, row - 1)\n\n start_idx = start_idx + len(self.dual_var_change) # go the the start pos of fields in field_names for fea_conditions\n for i in range(len(self.fea_conditions)): # for each fea_condition\n field = field_names[start_idx + i]\n\t\t if row > len(self.fea_conditions[field]) - 1:\n\t\t\ttemp_dict[field] = ''\n else: temp_dict[field] = self.get_fea_condition_value(field, row)\n\n writer.writerow(temp_dict)\n\n # we also save the value of primal values if not saved\n if not self.pdv_to_csv:\n self.save_last_prims()"],"string":"[\n \"def get_csv_string(self, **kwargs):\\n ...\",\n \"def to_csv(self, csvwriter):\\n csvwriter.writerow(self.to_csv_row())\",\n \"def toCsv(self, csv_path):\\n ser = pd.Series(self)\\n ser.to_csv(csv_path)\",\n \"def ToCsv(self):\\n\\n def csv_helper(the_dict, the_field):\\n if the_field not in the_dict:\\n return \\\"\\\"\\n value = the_dict[the_field]\\n if value is None:\\n return \\\"\\\"\\n if isinstance(value, set):\\n value = \\\"{}\\\".format(value)\\n #yes, I want to fallback to the previous case\\n\\n\\n if isinstance(value, str):\\n value = value.replace(\\\"\\\\\\\"\\\",\\\"\\\\\\\"\\\\\\\"\\\")\\n value = value.replace(\\\"\\\\r\\\",\\\"\\\")\\n #value = value.replace(\\\"\\\\n\\\",\\\"\\\\\\\\n\\\")\\n return \\\"\\\\\\\"{}\\\\\\\"\\\".format(value)\\n return value\\n\\n output = \\\"\\\"\\n first = True\\n for one_field in self.CSV_FIELDS:\\n if first:\\n first = False\\n template = \\\"{}{}\\\"\\n else:\\n template = \\\"{},{}\\\"\\n output = template.format(output, csv_helper(self.__dict__, one_field))\\n return output\",\n \"def _CsvFunc(self, obj=None, verbose=False, use_pager=None, to_file=None):\\n if obj is not None:\\n self._printed_variables.append(obj)\\n lines = describe.GenerateLines(obj, verbose=verbose, recursive=False,\\n format_name='csv')\\n _WriteToStream(lines, use_pager=use_pager, to_file=to_file)\",\n \"def write_csv(self, filelike):\\r\\n items = self.rows()\\r\\n writer = unicodecsv.writer(filelike, encoding=\\\"utf-8\\\")\\r\\n writer.writerow(self.header())\\r\\n for item in items:\\r\\n writer.writerow(item)\",\n \"def to_csv_file_obj(self, rows):\\n output = StringIO.StringIO()\\n writer = csv.writer(output)\\n writer.writerows(rows)\\n return output\",\n \"def save_csv(self, filename): # DONE\\n self.data.to_csv(filename)\",\n \"def __create_csv(self):\\n with open(self.__csv_file_name, 'w', newline='', encoding='utf-8') as csv_file:\\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\\n writer.writeheader()\",\n \"def to_csv(self, save_folder: Path) -> None:\\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\\n serializer.dump(instance=self, folder_path=save_folder)\",\n \"def store_csv(self):\\n\\n with open(self.filepath.with_suffix(\\\".csv\\\"), 'w',\\n newline='') as csvfile:\\n fieldnames = ['counter', 'timestamp', 'acceleration']\\n writer = DictWriter(csvfile, fieldnames=fieldnames)\\n\\n writer.writeheader()\\n writer.writerows(self.values)\",\n \"def _serialize_row(self, data):\\n if isinstance(data, str):\\n return data\\n\\n if isinstance(data, np.ndarray):\\n data = np.ndarray.flatten(data)\\n\\n if hasattr(data, \\\"__len__\\\"):\\n if len(data) == 0:\\n raise ValueError(\\\"Cannot serialize empty array\\\")\\n csv_buffer = io.StringIO()\\n csv_writer = csv.writer(csv_buffer, delimiter=\\\",\\\")\\n csv_writer.writerow(data)\\n return csv_buffer.getvalue().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n raise ValueError(\\\"Unable to handle input format: %s\\\" % type(data))\",\n \"def save_csv(self):\\n if not self.__is_csv():\\n # creates the csv file if it did not exist.\\n self.__create_csv()\\n try:\\n with open(self.__csv_file_name, 'a', newline='', encoding='utf-8') as csv_file:\\n writer = csv.DictWriter(csv_file, fieldnames=self.__csv_fields, delimiter=';')\\n writer.writerow(self.__values)\\n except IOError: # this exception avoid a product does not have saved in csv file\\n time.sleep(0.5)\\n self.save_csv()\\n # display on the screen what is being record on csv\\n for key, value in self.__values.items():\\n print('{}: {}'.format(key, value), end='; ' if key != 'url' else '\\\\n')\",\n \"def writeToCSV(self, filepath):\\r\\n\\t\\twith open(filepath, 'w') as outputFile:\\r\\n\\t\\t\\toutputFile.write(str(self))\",\n \"def _write_csv(self):\\n\\n # add the label to the header\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self.header.append('Date')\\n else:\\n self.header.append('sample id')\\n\\n key_list = []\\n\\n for i, cube in enumerate(self.cube_list):\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self._write_sample_with_date(cube, i, key_list)\\n else:\\n self._write_sample(cube, i, key_list)\\n\\n output_data_file_path = self._get_full_file_name()\\n self._write_data_dict(output_data_file_path, key_list)\\n\\n return [output_data_file_path]\",\n \"def csv(self, section=\\\"main\\\", column_headers=True):\\n table_end = \\\"\\\\r\\\\n\\\\r\\\\n\\\\r\\\\n\\\"\\n table_head_pos = self.header_dictionary[section]\\n table_end_pos = self.raw_data[table_head_pos:].find(table_end)\\n if table_end_pos == -1:\\n table_end_pos = len(self.raw_data)\\n else:\\n table_end_pos += table_head_pos\\n if column_headers:\\n a = \\\",\\\".join(self.columns()) + \\\"\\\\n\\\"\\n else:\\n a = \\\"\\\"\\n return a + self.raw_data[table_head_pos:table_end_pos].replace(\\\"\\\\t\\\",\\\",\\\").replace(\\\"\\\\r\\\",\\\"\\\")\",\n \"def get_csv_string(self):\\n df = None\\n for d in self.data:\\n if df is None:\\n df = d.as_dataframe()\\n else:\\n df = df.append(d.as_dataframe())\\n\\n if df is None:\\n return \\\"\\\"\\n else:\\n return df.to_csv(index=False)\",\n \"def write(self, file: IO) -> None:\\n serializer = self.serializer_class(self.get_queryset(), many=True)\\n\\n writer = csv.DictWriter(file, self.serializer_class.Meta.fields)\\n writer.writeheader()\\n\\n # Write serializer data and replace None/'' with 'NA'\\n writer.writerows(\\n OrderedDict(\\n (\\n field_name,\\n \\\"NA\\\" if (field_value is None or field_value == \\\"\\\") else field_value,\\n )\\n for field_name, field_value in row.items()\\n )\\n for row in serializer.data\\n )\\n\\n file.seek(0)\",\n \"def serialize(self, data):\\n if hasattr(data, \\\"read\\\"):\\n return data.read()\\n\\n if isinstance(data, DataFrame):\\n return data.to_csv(header=False, index=False)\\n\\n is_mutable_sequence_like = self._is_sequence_like(data) and hasattr(data, \\\"__setitem__\\\")\\n has_multiple_rows = len(data) > 0 and self._is_sequence_like(data[0])\\n\\n if is_mutable_sequence_like and has_multiple_rows:\\n return \\\"\\\\n\\\".join([self._serialize_row(row) for row in data])\\n\\n return self._serialize_row(data)\",\n \"def export_csv(header, data):\\n with StringIO() as tmp:\\n writer = csv.DictWriter(tmp, fieldnames=header)\\n writer.writeheader()\\n writer.writerows(data)\\n data = tmp.getvalue()\\n\\n return data\",\n \"def save_csv(self, filename: str, type='n', **args):\\n if type == 'n':\\n df = self.export_nodes()\\n else:\\n df = self.export_edges()\\n df.to_csv(filename, index=False)\",\n \"def save_csv(self):\\n path, _ = QtWidgets.QFileDialog.getSaveFileName(self, '保存数据', '', 'CSV(*.csv)')\\n\\n if not path:\\n return\\n\\n with open(path, 'w') as f:\\n writer = csv.writer(f, lineterminator='\\\\n')\\n\\n writer.writerow(self.headers.keys())\\n\\n for row in range(self.rowCount()):\\n row_data = []\\n for column in range(self.columnCount()):\\n item = self.item(row, column)\\n if item:\\n row_data.append(str(item.text()))\\n else:\\n row_data.append('')\\n writer.writerow(row_data)\",\n \"def to_csv(self, filename, **kwargs):\\n self.data.to_csv(filename, **kwargs)\",\n \"def _csv_export(self, exppath):\\n with open(exppath, 'w') as csvfile:\\n csvwriter = csv.writer(csvfile, delimiter=',', skipinitialspace=True)\\n csvwriter.writerow(['hexstr','dmc','name'])\\n for clr in self.lookup_table:\\n csvwriter.writerow([clr.hex.to_str(), clr.id, clr.name])\",\n \"def queryset_to_csv(self):\\n csv_data = []\\n custom_fields = []\\n\\n # Start with the column headers\\n headers = self.queryset.model.csv_headers.copy()\\n\\n # Add custom field headers, if any\\n if hasattr(self.queryset.model, 'get_custom_fields'):\\n for custom_field in self.queryset.model().get_custom_fields():\\n headers.append(custom_field.name)\\n custom_fields.append(custom_field.name)\\n\\n csv_data.append(','.join(headers))\\n\\n # Iterate through the queryset appending each object\\n for obj in self.queryset:\\n data = obj.to_csv()\\n\\n for custom_field in custom_fields:\\n data += (obj.cf.get(custom_field, ''),)\\n\\n csv_data.append(csv_format(data))\\n\\n return '\\\\n'.join(csv_data)\",\n \"def DumpCsv(data):\\n \\n raise Exception('TBI: Need standard container structure for this to work, cause its flat...')\",\n \"def read_csv():\",\n \"def create_csv_file(self):\\r\\n # Create a new csv-file\\r\\n with open(self.fname, 'w') as f:\\r\\n writer = csv.writer(f, dialect='excel')\\r\\n writer.writerow(['set_time',\\r\\n 'read_time_P_ac',\\r\\n 'read_time_P_bat',\\r\\n 'soc',\\r\\n 'set_value',\\r\\n 'P_ac',\\r\\n 'P_bat'])\",\n \"def csv_content(self):\\n if not hasattr(self, 'CSV_COLUMNS'):\\n raise NotImplementedError('Child classes of CsvForm must implement the CSV_COLUMNS constant')\\n\\n # Get column fields and headers\\n csv_columns = [i['column'] for i in self.CSV_COLUMNS]\\n csv_headers = [i['title'].encode('utf-8') for i in self.CSV_COLUMNS]\\n\\n # Build data for csv writer\\n csv_data = []\\n for obj in self.get_queryset():\\n csv_data.append([unicode(csv_getvalue(obj, column)).encode('utf-8') for column in csv_columns])\\n\\n # Create buffer with csv content\\n content = StringIO()\\n writer = csv.writer(content)\\n writer.writerow(csv_headers)\\n writer.writerows(csv_data)\\n content.seek(0)\\n\\n return content\",\n \"def csv(self):\\n return '{:.6f},{:.6f},{},{}'.format(\\n self.sample_time, self.value_time, self.value, self.status)\",\n \"def write_to_file(data, method, delimiter):\\r\\n output_file = 'data.csv'\\r\\n with open(output_file, method, newline='', encoding='utf-8') as file:\\r\\n writer = csv.writer(file, delimiter=delimiter)\\r\\n writer.writerows([data])\",\n \"def generate_csv_file(rows: Collection[dict[str, str]]):\\n file = io.StringIO()\\n csv_writer = csv.DictWriter(file, (\\\"label\\\", \\\"inventory\\\", \\\"collection\\\"))\\n csv_writer.writeheader()\\n csv_writer.writerows(rows)\\n file.seek(0)\\n return io.BytesIO(bytes(file.read(), encoding=\\\"utf-8\\\"))\",\n \"def to_csv(self, filename):\\n self.data.to_csv(filename)\",\n \"def to_csv(self, filename):\\n self.data.to_csv(filename)\",\n \"def csv(self):\\n return '{:.6f},{},{}'.format(self.sample_time, self.value, self.status)\",\n \"def _csv(content):\\n response = _data_frame(content).to_csv(index=False)\\n return response\",\n \"def _csvWriter(self):\\r\\n # Initialize Header\\r\\n table = []\\r\\n voltageRow = []\\r\\n for i in range(len(self._voltages)):\\r\\n voltageRow.append(self._voltages[i][0])\\r\\n voltageRow.append(\\\" \\\")\\r\\n if self._vna.isTwoComponents():\\r\\n voltageRow.append(\\\" \\\")\\r\\n table.append(voltageRow)\\r\\n \\r\\n # Fill table with data\\r\\n # if self._vna.isTwoComponents():\\r\\n # for i in range(len(self._frequency[0])):\\r\\n # row = []\\r\\n # for j in range(len(self._frequency)):\\r\\n # row.append(self._frequency[j][i])\\r\\n # row.append(self._intensity[j][2*i])\\r\\n # row.append(self._intensity[j][2*i + 1])\\r\\n # table.append(row)\\r\\n # else: \\r\\n for i in range(len(self._frequency[0])):\\r\\n row = []\\r\\n for j in range(len(self._frequency)):\\r\\n row.append(self._frequency[j][i])\\r\\n row.append(self._intensity[j][i])\\r\\n table.append(row)\\r\\n\\r\\n # Write to CSV\\r\\n filename = 'CSVs/' + self._vna.getDateFormatted() + '.csv'\\r\\n with open(filename, 'w', newline='') as csvfile:\\r\\n dataWriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)\\r\\n for i in range(len(table)):\\r\\n dataWriter.writerow(table[i])\",\n \"def as_csv(obj, f):\\n val = getattr(obj, f)\\n if sys.version_info >= (3, 0) and type(val) is bytes:\\n return val.decode()\\n return val\",\n \"def exportCSV(self, log, csvFile):\\n return 0\",\n \"def setup_csv(self) -> None:\\n csvData = ['Followers', 'Time']\\n\\n # Create our CSV file header\\n with open(self.graphfile, 'w') as csvFile:\\n writer = csv.writer(csvFile)\\n writer.writerow(csvData)\\n csvFile.close()\",\n \"def __init__(self, content_type=\\\"text/csv\\\"):\\n super(CSVSerializer, self).__init__(content_type=content_type)\",\n \"def generateCsvData(self, context, obj, entity):\\n raise NotImplementedError()\",\n \"def csv_output(self):\\r\\n fh = open(\\\"output.csv\\\",'w')\\r\\n for i in range(len(self.population.columns)):\\r\\n if i != len(self.population.columns)-1:\\r\\n fh.write(str(self.population.columns[i]))\\r\\n fh.write(\\\",\\\")\\r\\n else:\\r\\n fh.write(str(self.population.columns[i]))\\r\\n fh.write(\\\"\\\\n\\\")\\r\\n\\r\\n for i in range(len(self.population.data)):\\r\\n for j in range(len(self.population.data[i])):\\r\\n if j != len(self.population.data[i])-1:\\r\\n fh.write(str(self.population.data[i][j]))\\r\\n fh.write(\\\",\\\")\\r\\n else:\\r\\n fh.write(str(self.population.data[i][j]))\\r\\n fh.write(\\\"\\\\n\\\")\\r\\n fh.close()\",\n \"def export_to_csv(self, request, queryset):\\n fields = self.get_table_fields()\\n field_names = [field.name for field in fields]\\n field_verbose_names = [field.verbose_name.encode(\\n 'utf-8'\\n ) for field in fields]\\n\\n response = HttpResponse(content_type='text/csv')\\n response['Content-Disposition'] = 'attachment; \\\\\\nfilename=%s.csv' % unicode(self.model._meta).replace('.', '_')\\n\\n writer = csv.writer(response)\\n writer.writerow(field_verbose_names)\\n for obj in queryset:\\n writer.writerow([unicode(getattr(obj, field)).encode(\\n \\\"utf-8\\\",\\n \\\"replace\\\"\\n ) for field in field_names])\\n return response\",\n \"def CSVstr(self):\\n return self.start.CSVstr() + ',' + self.end.CSVstr()\",\n \"def CSVLine(self):\\n \\t\\n l = []\\n for k in sorted(Statistics.attrs.keys()):\\n l.append(self.__dict__[k])\\n\\n return ','.join(str(i) for i in l)\",\n \"def csv_writer(data, path):\\n\\twith open(path, \\\"wb\\\") as csv_file:\\n\\t\\twriter= csv.writer(csv_file, delimiter=',')\\n\\t\\twriter.writerows(data)\",\n \"def to_csv(self, dataset):\\n save_as = filedialog.asksaveasfilename(defaultextension='.csv')\\n try:\\n with open(save_as, 'w', newline='') as file:\\n scribe = csv.writer(file)\\n scribe.writerow(HEADERS)\\n for row in dataset:\\n scribe.writerow(row.values())\\n self.info_success(save_as)\\n except IOError:\\n self.info_error()\\n return\",\n \"def writeCSV(filename, separator, data):\\n \\n filetowrite = open(filename, \\\"w\\\")\\n values = []\\n i = 0 #Count the number of objects already written\\n for item in data:\\n filetowrite.write(item)\\n i += 1\\n if i < len(data.keys()):\\n filetowrite.write(separator)\\n values.append(data[item])\\n filetowrite.write(\\\"\\\\n\\\")\\n i = 0\\n for value in values:\\n filetowrite.write(str(value))\\n i += 1\\n if i < len(values):\\n filetowrite.write(separator)\\n \\n filetowrite.close()\",\n \"def csv_file(data,output_dir,filename,order = [],head = True):\\n with open(output_dir + filename + '.csv', 'w') as f:\\n write = csv.writer(f)\\n write.writerows(manip.dic_to_list(data,order,head),)\\n return None\",\n \"def export_csv(self, path):\\r\\n\\r\\n with open(path, 'w') as f:\\r\\n f.write('# h,hr,m')\\r\\n\\r\\n if self.rho is not None:\\r\\n f.write(',rho')\\r\\n if self.temperature is not None:\\r\\n f.write(',temperature')\\r\\n\\r\\n f.write('\\\\n')\\r\\n for i in range(self.shape[0]):\\r\\n for j in range(self.shape[1]):\\r\\n f.write(f'{self.h[i, j]},{self.hr[i, j]},{self.m[i, j]}')\\r\\n if self.rho is not None:\\r\\n f.write(f',{self.rho[i, j]}')\\r\\n if self.temperature is not None:\\r\\n f.write(f',{self.temperature[i, j]}')\\r\\n f.write('\\\\n')\\r\\n return\",\n \"def csv(self, destination_path):\\n # todo - test for single and duplicate base cases\\n to_csv(self._axl_data, destination_path)\",\n \"def to_csv(self, filename, **csv_args):\\n dataframe = pd.DataFrame.from_dict(self.to_dict())\\n return dataframe.to_csv(filename, **csv_args)\",\n \"def csv_data():\\r\\n for row in data:\\r\\n writer.writerow(row)\\r\\n csv_data = read_and_flush()\\r\\n yield csv_data\",\n \"def __open_csv(self):\\n self.__csv_file = open(self.__csv_file_name, 'w', encoding='utf-8')\\n self.__csv_writer = csv.writer(self.__csv_file, delimiter=',', )\",\n \"def to_csv(val):\\n # Make sure all individual values do not contain\\n # leading or trailing whitespaces.\\n unicode_values = list(map(str.strip, map(str, val)))\\n stream = StringIO()\\n writer = csv.writer(stream, dialect=\\\"excel\\\")\\n writer.writerow(unicode_values)\\n # Strip any csv.writer added carriage return line feeds\\n # and double quotes before saving.\\n csv_string = stream.getvalue().strip().strip('\\\"')\\n if len(unicode_values) > 1:\\n csv_string = \\\"[\\\" + csv_string + \\\"]\\\"\\n return csv_string\",\n \"def write_csv(self, file):\\n # Write header row\\n file.write('Timestamp,MessageType,Queue,Price,Volume,OrderID\\\\n')\\n # Write content\\n for x in self.records:\\n row = (str(x[0]) + ',' + x[1][\\\"MessageType\\\"] + ',' +\\n x[1][\\\"Queue\\\"] + ',' + str(x[1][\\\"Price\\\"]) + ',' +\\n str(x[1][\\\"Volume\\\"]) + ',' + str(x[1][\\\"OrderID\\\"]) + '\\\\n')\\n file.write(row)\",\n \"def save_to_file_csv(cls, list_objs):\\n l = []\\n if list_objs is not None:\\n for item in list_objs:\\n l.append(item.to_dictionary())\\n with open(\\\"%s.csv\\\" % cls.__name__, mode='w') as f:\\n f.write(Base.to_json_string(l))\",\n \"def to_csv(self, csv_path) -> None:\\n families = []\\n for row in self.rows:\\n row.assign_seats()\\n families += row.families\\n families.sort(key=lambda f: f.name)\\n\\n with open(csv_path, mode='w') as f:\\n writer = csv.writer(f)\\n writer.writerow(['Family Name', 'Seats'])\\n for fam in families:\\n writer.writerow([fam.name, *fam.seats])\",\n \"def generate_csv(inf, outf):\\n o = csv.writer(outf)\\n o.writerow(COLUMNS)\\n for row in reformat_data(inf):\\n o.writerow([inf.name] + row)\",\n \"def writetoCSV(self, fileName):\\n\\n with open(fileName, 'w') as writeFile:\\n writeFile.write(\\\"ID,Fx,Fy,Fz\\\\n\\\")\\n for fstnr in F:\\n writeFile.write(str(fstnr.ID))\\n for i in fstnr.force:\\n writeFile.write(',' + str(i))\\n writeFile.write('\\\\n')\",\n \"def saveCsv(self, filePath = None, rowDeliminator = None, columnDeliminator = None, sheetDeliminator = None, yieldForNone = \\\"\\\", skipLineCondition = None):\\n\\n\\t\\t\\tdef yieldValues(row):\\n\\t\\t\\t\\tfor cell in row:\\n\\t\\t\\t\\t\\tvalue = cell.value\\n\\t\\t\\t\\t\\tif (value is None):\\n\\t\\t\\t\\t\\t\\tyield yieldForNone\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tyield value\\n\\n\\t\\t\\tif (skipLineCondition is None):\\n\\t\\t\\t\\tdef yieldRows(mySheet):\\n\\t\\t\\t\\t\\tfor row in mySheet.thing.rows:\\n\\t\\t\\t\\t\\t\\tyield rowDeliminator.join(yieldValues(row))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdef yieldRows(mySheet):\\n\\t\\t\\t\\t\\tfor row in mySheet.thing.rows:\\n\\t\\t\\t\\t\\t\\tif (not skipLineCondition(row)):\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\tyield rowDeliminator.join(yieldValues(row))\\n\\n\\t\\t\\tdef yieldSheet():\\n\\t\\t\\t\\tnonlocal self\\n\\n\\t\\t\\t\\tfor mySheet in self:\\n\\t\\t\\t\\t\\tyield columnDeliminator.join(yieldRows(mySheet))\\n\\n\\t\\t\\t############################\\n\\n\\t\\t\\trowDeliminator = self.ensure_default(rowDeliminator, \\\",\\\")\\n\\t\\t\\tsheetDeliminator = self.ensure_default(sheetDeliminator, \\\"\\\\n\\\")\\n\\t\\t\\tcolumnDeliminator = self.ensure_default(columnDeliminator, \\\"\\\\n\\\")\\n\\n\\t\\t\\t_filePath = self.ensure_filePath(self.ensure_default(filePath, default = self.filePath), ending = (\\\".csv\\\"), checkExists = False)\\n\\t\\t\\twith open(_filePath, \\\"w+\\\") as fileHandle:\\n\\t\\t\\t\\tfileHandle.write(sheetDeliminator.join(yieldSheet()))\",\n \"def save(self, path, separator=\\\",\\\", encoder=lambda j,v: v):\\n # csv.writer will handle str, int, float and bool:\\n s = StringIO()\\n w = csv.writer(s, delimiter=separator)\\n w.writerows([[encode_utf8(encoder(j,v)) for j,v in enumerate(row)] for row in self])\\n f = open(path, \\\"wb\\\")\\n f.write(BOM_UTF8)\\n f.write(s.getvalue())\\n f.close()\",\n \"def csv_export(self,\\n states=None,\\n fields=None,\\n filenamebase='projects',\\n delimiter=',',\\n newline='\\\\r\\\\n',\\n ):\\n \\n if fields is None:\\n fields = self.fields()\\n \\n out = StringIO()\\n out.write(delimiter.join(fields) + newline)\\n\\n for project in self.data():\\n values = []\\n for field in project:\\n text = field['text']\\n if type(text) is UnicodeType:\\n text = text.encode('utf8')\\n value = CSV_TEMPLATE % text\\n values.append(value)\\n out.write(delimiter.join(values) + newline)\\n \\n value = out.getvalue()\\n out.close()\\n\\n timestamp = datetime.today().strftime(\\\"%Y%m%d%H%M\\\")\\n filename = filenamebase + timestamp + '.csv'\\n \\n self.request.RESPONSE.setHeader('Content-Type', 'application/x-msexcel')\\n self.request.RESPONSE.setHeader(\\\"Content-Disposition\\\", \\n \\\"inline;filename=%s\\\"%filename)\\n\\n return value\",\n \"def get_csv_line(self):\\n return \\\"{},{},{},{},{},{},{}\\\\n\\\".format(self.employee_id, self.gender,\\n self.sales, self.bmi,\\n self.salary,\\n self.get_birthday_string(),\\n self.age)\",\n \"def serialize(self, pid, record, links_factory=None):\\n record = self.process_dict(self.transform_record(pid, record, links_factory))\\n\\n return self._format_csv([record])\",\n \"def file(self):\\n result = []\\n completePath = CompletePath(self.path, self.filename) \\n with open(completePath.path(), 'w', newline='') as csvfile:\\n fieldnames = ['Activity', 'Points']\\n writer = csv.DictWriter(csvfile, fieldnames = fieldnames)\\n writer.writeheader()\\n for i in range ( len( self.groupPriority.rows() ) ):\\n tmp = self.groupPriority.rows()[i]\\n self.log.info ( \\\"FinalCSV\\\", \\\"file\\\",\\\"data {0},{1}\\\".format( tmp.activity(), tmp.points() ) )\\n writer.writerow({'Activity': tmp.activity(), 'Points': tmp.points()})\\n self.log.info(\\\"FinalCSV\\\", \\\"file\\\", \\\"Elaborated file: {0}\\\".format ( completePath.path() ) )\",\n \"def gen_csv(self, show_headers=True, show_tags=True):\\n class TextOut:\\n \\\"\\\"\\\"Simple string output source to capture CSV\\\"\\\"\\\"\\n def __init__(self):\\n self.data = ''\\n def write(self, s):\\n self.data += s\\n def get(self):\\n data = self.data\\n self.data = ''\\n return data\\n output = TextOut()\\n writer = csv.writer(output)\\n for raw in self.gen_raw(show_headers, show_tags):\\n writer.writerow(raw)\\n yield output.get()\",\n \"def save_csv(data): \\n bank_data = data\\n\\n #Creating headers for the csv file\\n header = [\\\"Lender\\\", \\\"Max Loan Amount\\\", \\\"Max LTV\\\", \\\"Max DTI\\\", \\\"Max Credit Score\\\", \\\"Interest Rate\\\"]\\n\\n #Creating output path of the CSV file\\n csvpath = Path(\\\"save_file.csv\\\")\\n\\n #Opening the csv file in csvpath by using the open() method\\n with open(csvpath, \\\"w\\\", newline='') as csvfile:\\n\\n csvwriter = csv.writer(csvfile, delimiter = \\\",\\\")\\n csvwriter.writerow(header)\\n for row in bank_data:\\n csvwriter.writerow(row)\\n\\n return data\",\n \"def csv_write (data):\\n \\n csv_data=data[0:]\\n csv1_data = open('backup.csv', 'a')\\n csvwriter = csv.writer(csv1_data)\\n\\n count = 0\\n\\n for i in csv_data:\\n if count == 0:\\n header = i.keys()\\n csvwriter.writerow(header)\\n count += 1\\n csvwriter.writerow(i.values())\\n\\n csv1_data.close()\\n\\n #http://blog.appliedinformaticsinc.com/how-to-parse-and-convert-json-to-csv-using-python/\",\n \"def save_to_csv(self):\\r\\n # Save the read values to a csv file\\r\\n with open(self.fname, \\\"a\\\") as f:\\r\\n wr = csv.writer(f, dialect='excel')\\r\\n wr.writerow([self.set_time, self.read_time_P_ac, self.read_time_P_bat,\\r\\n self.soc0, self.set_val, self.P_ac, self.P_bat])\",\n \"def encode_csv(self, dt, ss_code, ss_config, blank, bin_size):\\r\\n str_result = []\\r\\n\\r\\n for beam in range(self.element_multiplier):\\r\\n for bin_num in range(self.num_elements):\\r\\n # Get the value\\r\\n val = self.Amplitude[bin_num][beam]\\r\\n\\r\\n # Create the CSV string\\r\\n str_result.append(Ensemble.gen_csv_line(dt, Ensemble.CSV_AMP, ss_code, ss_config, bin_num, beam, blank, bin_size, val))\\r\\n\\r\\n return str_result\",\n \"def to_csv(header, rows):\\r\\n with open('result.csv', 'w') as result:\\r\\n result_writer = csv.writer(result, delimiter=';')\\r\\n result_writer.writerow(header)\\r\\n result_writer.writerows(rows)\",\n \"def write_csv(fn, toCSV):\\n keys = toCSV[0].keys()\\n with open(fn, 'w') as output_file:\\n dict_writer = csv.DictWriter(output_file, keys)\\n dict_writer.writeheader()\\n dict_writer.writerows(toCSV)\",\n \"def generate_dataset_csv(request):\\n\\n response = csv_export(request,Dataset)\\n return response\",\n \"def to_csv(self, file_path: str) -> None:\\n with open(file_path, \\\"w\\\") as f:\\n writer = csv.writer(f)\\n writer.writerow([\\\"parameter\\\", \\\"value\\\"])\\n writer.writerow([\\\"render\\\", str(self.render)])\\n writer.writerow([\\\"sleep\\\", str(self.sleep)])\\n writer.writerow([\\\"log_frequency\\\", str(self.log_frequency)])\\n writer.writerow([\\\"video\\\", str(self.video)])\\n writer.writerow([\\\"video_fps\\\", str(self.video_fps)])\\n writer.writerow([\\\"video_dir\\\", str(self.video_dir)])\\n writer.writerow([\\\"num_episodes\\\", str(self.num_episodes)])\\n writer.writerow([\\\"gifs\\\", str(self.gifs)])\\n writer.writerow([\\\"gifdir\\\", str(self.gif_dir)])\\n writer.writerow([\\\"video_frequency\\\", str(self.video_frequency)])\",\n \"def csv(filepath, header=True, mode=DataSaver.MODE_OVERWRITE, sep=',',\\n na_rep='', float_format=None, columns=None, encoding=None,\\n quoting=None, quotechar='\\\"', date_format=None, doublequote=True,\\n escapechar=None, decimal='.'):\\n\\n format_file = DataSaver.FORMAT_CSV\\n kwargs = locals()\\n _apply_datasaver(format_file, kwargs, last_uuid)\\n return None\",\n \"def export_csv(self):\\n outputfile = tkinter.filedialog.asksaveasfilename(\\n defaultextension=\\\".csv\\\",\\n filetypes=((\\\"comma seperated values\\\", \\\"*.csv\\\"),\\n (\\\"All Files\\\", \\\"*.*\\\")))\\n if outputfile:\\n tabledata = self.tabs.window.aistracker.create_table_data()\\n export.write_csv_file(tabledata, outputfile)\\n else:\\n raise ExportAborted('Export cancelled by user.')\",\n \"def dump_csv(f, rra, out):\\n w = writer(out)\\n for row in dump(f, rra):\\n w.writerow([s.strip() for s in row])\",\n \"def _getCSVForPerField(self, statistic):\\n\\n rows = []\\n\\n chart_json = simplejson.loads(statistic.chart_json)\\n description = chart_json['description'] \\n header = []\\n for item in description:\\n header.append(item[-1].encode('utf-8'))\\n rows.append(header)\\n\\n final_stat = simplejson.loads(statistic.final_json)\\n for choice, result in final_stat.iteritems():\\n row = []\\n row.append(unicode(choice).encode('utf-8'))\\n for item in result:\\n row.append(unicode(item).encode('utf-8'))\\n rows.append(row)\\n\\n return rows\",\n \"def csv_writer(data, path):\\n\\n with open(path, \\\"a\\\") as csv_file:\\n\\n writer = csv.writer(csv_file,delimiter=',')\\n\\n \\n\\n writer.writerow(data)\",\n \"def prepare_CSV(self):\\n self.drop_columns()\\n self.rename_columns()\\n self.spilt_columns()\\n self.add_vehicle_id_column()\\n self.add_source_column()\\n self.add_timestamp_columns()\\n self.get_colour_columns()\\n self.clean_column_formats()\\n\\n # print(self.data.info())\\n # print(self.data.sample(10))\\n\\n return self.data\",\n \"def exportcsvsumdata(self, log):\\r\\n csvdata= None\\r\\n\\r\\n if (log):\\r\\n csvdata = ('%s\\\\t'%(log['CALLSIGN']))\\r\\n csvdata += ('%s\\\\t'%(log['OPERATORS']))\\r\\n csvdata += ('%s\\\\t'%(log['LOCATION']))\\r\\n csvdata += ('%d\\\\t'%(log['COUNT']))\\r\\n csvdata += ('%s\\\\t'%(log['NAMES']))\\r\\n if(log['LASTWORKED']): \\r\\n csvdata += ('%s/%s UTC'%(log['LASTWORKED'],\\r\\n log['LWTIME'])) \\r\\n\\r\\n return csvdata\",\n \"def save_to_file_csv(cls, list_objs):\\n list_dictionaries = []\\n if list_objs is None or list_objs == []:\\n string_dictionary = \\\"[]\\\"\\n else:\\n for _obj_dict in list_objs:\\n list_dictionaries.append(_obj_dict.to_dictionary())\\n string_dictionary = Base.to_json_string(list_dictionaries)\\n with open(cls.__name__ + \\\".csv\\\", \\\"w\\\") as _file:\\n _file.write(string_dictionary)\\n _file.close()\",\n \"def toCsvStrings(self) -> List[str]:\\n return [str(self.getId()),\\n str(self.getLeftNode().getId()),\\n str(self.getRightNode().getId()),\\n CsvWriter.shortenDecimalValueForOutput(self.getLength()),\\n str(self.getLowerBound()),\\n str(self.getUpperBound())]\",\n \"def save_csv(filename, rows):\\n with open(filename, 'w', newline='', encoding='utf-8') as f:\\n writer = csv.writer(f)\\n writer.writerow([\\n 'title', 'runtime', 'genre(s)', 'director(s)', 'writer(s)',\\n 'actor(s)', 'rating(s)', 'number of rating(s)'\\n ])\\n\\n writer.writerows(rows)\",\n \"def return_csv(func, datatable, file_pointer=None):\\r\\n if file_pointer is None:\\r\\n response = HttpResponse(mimetype='text/csv')\\r\\n response['Content-Disposition'] = 'attachment; filename={0}'.format(func)\\r\\n else:\\r\\n response = file_pointer\\r\\n writer = csv.writer(response, dialect='excel', quotechar='\\\"', quoting=csv.QUOTE_ALL)\\r\\n encoded_row = [unicode(s).encode('utf-8') for s in datatable['header']]\\r\\n writer.writerow(encoded_row)\\r\\n for datarow in datatable['data']:\\r\\n # 's' here may be an integer, float (eg score) or string (eg student name)\\r\\n encoded_row = [\\r\\n # If s is already a UTF-8 string, trying to make a unicode\\r\\n # object out of it will fail unless we pass in an encoding to\\r\\n # the constructor. But we can't do that across the board,\\r\\n # because s is often a numeric type. So just do this.\\r\\n s if isinstance(s, str) else unicode(s).encode('utf-8')\\r\\n for s in datarow\\r\\n ]\\r\\n writer.writerow(encoded_row)\\r\\n return response\",\n \"def csv_pickle():\\n data_dire = 'data'\\n requests_csv = os.path.join(data_dire, 'requests.csv')\\n supply_csv = os.path.join(data_dire, 'supply.csv')\\n transport_csv = os.path.join(data_dire, 'transport.csv')\\n\\n tc = TransicationRecord.from_csv(supply_csv, requests_csv)\\n tp = TransportRecord.from_csv(transport_csv)\\n\\n Record.to_pickled(os.path.join(data_dire, 'transication.bin'), tc)\\n Record.to_pickled(os.path.join(data_dire, 'transport.bin'), tp)\",\n \"def csvprint(self, data):\\n import csv\\n import sys\\n # self._assert(data) CSV data row lenght can vary\\n data = self._render(data) # make elements ascii\\n writer = csv.writer(sys.stdout, delimiter=',',\\n quotechar='\\\"', \\n quoting=csv.QUOTE_MINIMAL,\\n lineterminator=\\\"\\\\n\\\")\\n for row in data: writer.writerow(row)\",\n \"def to_csv(parameters: List['Parameter'], filename: str):\\n lines = [parameters[0].keys()]\\n for parameter in parameters:\\n lines.append(Parameter.to_strs(parameter.values()))\\n FileUtiles.csvSave(filename, lines)\",\n \"def to_csv_line(*args):\\r\\n return ','.join([str(value) for value in args]) + '\\\\n'\",\n \"def export_csv(self, csvfileobject):\\n for index, track in enumerate(self._tracks):\\n csvfileobject.writerow(track.properties)\\n for delta in track.periods: \\n csvfileobject.writerow(delta.properties)\",\n \"def export_as_csv(modeladmin, request, queryset):\\n if not request.user.is_staff:\\n raise PermissionDenied\\n opts = modeladmin.model._meta\\n response = HttpResponse(mimetype='text/csv')\\n response['Content-Disposition'] = 'attachment; filename=%s.csv' % unicode(opts).replace('.', '_')\\n writer = csv.writer(response, delimiter=';')\\n field_names = [field.name for field in opts.fields]\\n # Write a first row with header information\\n writer.writerow(field_names)\\n # Write data rows\\n for obj in queryset:\\n values = []\\n for field in field_names:\\n value = (getattr(obj, field))\\n if callable(value):\\n try:\\n value = value() or ''\\n except:\\n value = 'Error retrieving value'\\n if value is None:\\n value = ''\\n values.append(unicode(value).encode('utf-8'))\\n writer.writerow(values)\\n #writer.writerow([getattr(obj, field) for field in field_names])\\n return response\",\n \"def write_csv(fhandle, outages, fields):\\n writer = csv.DictWriter(fhandle, fields)\\n writer.writeheader()\\n writer.writerows([o.for_json() for o in outages])\",\n \"def exportCSV(self, fields=None, coding=None, delimiter='semicolon'):\\n\\n result = self.generateCSV(fields=fields, delimiter=delimiter)\\n\\n # encode the result\\n charset = self._site_encoding()\\n if coding:\\n result = result.decode(charset).encode(coding)\\n else:\\n coding = charset\\n\\n # set headers and return\\n setheader = self.request.RESPONSE.setHeader\\n setheader('Content-Length', len(result))\\n setheader('Content-Type',\\n 'text/x-comma-separated-values; charset=%s' % coding)\\n setheader('Content-Disposition',\\n 'attachment; filename=%s.csv' % self.context.getId())\\n return result\",\n \"def _export_csv(x, y, export_to):\\r\\n\\r\\n with open(export_to, 'w', newline='') as e:\\r\\n writer = csv.writer(e, delimiter=',')\\r\\n for i in range (0, len(x)):\\r\\n writer.writerow([x[i], y[i]])\",\n \"def to_csv_files(self, path):\\n self._to_dict_tree().to_csv_files(path)\",\n \"def getCsvData(self):\\n return [View.getTableHead()] + self.getTableData()\",\n \"def to_csv(self, path=None, sep=',', data_format=DataFormat.RAW, csv_dialect='excel'):\\n\\n if path is None:\\n file_handle = StringIO()\\n self._write_csv(file_handle, csv_dialect, sep, data_format)\\n return file_handle.getvalue()\\n\\n # Path provided\\n with open(path, 'w') as file_handle:\\n self._write_csv(file_handle, csv_dialect, sep, data_format)\",\n \"def saveCSV(self):\\n filename=tkFileDialog.asksaveasfilename(defaultextension='.csv',\\n initialdir=os.getcwd(),\\n filetypes=[(\\\"csv\\\",\\\"*.csv\\\"),(\\\"All files\\\",\\\"*.*\\\")])\\n if not filename:\\n return\\n for m in self.matrices:\\n matrix = self.matrices[m] \\n if matrix != None: \\n c=matrix.csvRepresentation()\\n f=open(filename,'w')\\n f.write(c)\\n f.close()\\n return\",\n \"def write_to_csv(self, name_suffix = ''):\\n f_path = os.path.join(self.root_dir, 'res' + name_suffix + '.csv')\\n field_names = [] # the first field in CSV is 'obj_val'\\n\\n # put the keys in the cost, prim_var_change, dual_var_change and fea_conditions as field names if any\\n for key in self.cost.keys():\\n field_names.append(key)\\n for key in self.cost_change.keys():\\n field_names.append(key)\\n for key in self.prim_var_change.keys():\\n field_names.append(key)\\n for key in self.dual_var_change.keys():\\n field_names.append(key)\\n for key in self.fea_conditions.keys():\\n field_names.append(key)\\n\\n\\tprint f_path\\n\\n with open(f_path, mode = 'wb') as csv_file: # open the file, if not exist, create it\\n writer = csv.DictWriter(csv_file, fieldnames = field_names) # create a writer which maps the dictionaries onto output rows in CSV\\n writer.writeheader() # write the field names to the header\\n temp_dict = {} # create a temporary dict used to output rows\\n row_max = self.get_iter_num() # get the max iters which indicates the number of rows in CSV\\n print ('number of rows: ' + str(row_max))\\n #print (field_names)\\n for row in range(row_max + 1):\\n temp_dict.clear() # clear all items\\n start_idx = 0\\n for i in range(len(self.cost)):\\n field = field_names[start_idx + i]\\n\\t\\t if row > len(self.cost[field]) - 1:\\n\\t\\t\\ttemp_dict[field] = ''\\n\\t\\t else: temp_dict[field] = self.get_cost_val(field, row)\\n\\n start_idx = start_idx + len(self.cost) # the start pos of fields in field_names for prim_var_change\\n for i in range(len(self.cost_change)): # for each cost_change\\n field = field_names[start_idx + i]\\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of primal variables\\n temp_dict[field] = '/'\\n elif row > len(self.cost_change[field]) - 1:\\n\\t\\t\\t temp_dict[field] = ''\\n\\t\\t else:\\n temp_dict[field] = self.get_cost_change_value(field, row - 1)\\n\\n\\n start_idx = start_idx + len(self.cost_change)\\n for i in range(len(self.prim_var_change)): # for each prim_var_change\\n field = field_names[start_idx + i]\\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of primal variables\\n temp_dict[field] = '/'\\n\\t\\t elif row > len(self.prim_var_change[field]) - 1:\\n\\t\\t\\ttemp_dict[field] = ''\\n else:\\n temp_dict[field] = self.get_prim_change_value(field, row - 1)\\n\\n start_idx = start_idx + len(self.prim_var_change) # go to the start pos of fields in field_names for dual_var_change\\n for i in range(len(self.dual_var_change)): # for each dual_var_change\\n field = field_names[start_idx + i]\\n if row == 0: # for row 0 (iter 0), we will set '/' to the change of dual variables\\n temp_dict[field] = '/'\\n elif row > len(self.dual_var_change[field]) - 1:\\n\\t\\t\\ttemp_dict[field] = '' \\n\\t\\t else:\\n temp_dict[field] = self.get_dual_change_value(field, row - 1)\\n\\n start_idx = start_idx + len(self.dual_var_change) # go the the start pos of fields in field_names for fea_conditions\\n for i in range(len(self.fea_conditions)): # for each fea_condition\\n field = field_names[start_idx + i]\\n\\t\\t if row > len(self.fea_conditions[field]) - 1:\\n\\t\\t\\ttemp_dict[field] = ''\\n else: temp_dict[field] = self.get_fea_condition_value(field, row)\\n\\n writer.writerow(temp_dict)\\n\\n # we also save the value of primal values if not saved\\n if not self.pdv_to_csv:\\n self.save_last_prims()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73075175","0.7227191","0.7032894","0.70270133","0.6928391","0.6888921","0.6879478","0.6835335","0.67983305","0.665103","0.6593733","0.6589045","0.6541852","0.6517649","0.6497261","0.6496066","0.6471588","0.64418876","0.6415566","0.6408056","0.6371749","0.63470167","0.6333958","0.6332543","0.6329317","0.63217056","0.63116276","0.6291042","0.6286879","0.62822694","0.6280209","0.6275323","0.62566614","0.62566614","0.62556756","0.6253307","0.62506217","0.62459886","0.6243787","0.6238656","0.62236696","0.6216309","0.6216038","0.62135446","0.621199","0.62092113","0.62085176","0.62084275","0.6206367","0.62057936","0.6202548","0.62024385","0.61991733","0.6183753","0.618301","0.6165588","0.6160859","0.61578417","0.6156961","0.61370033","0.61369795","0.6132162","0.6095926","0.6092451","0.606533","0.6062987","0.6060261","0.60531044","0.6044881","0.604445","0.6041295","0.60327774","0.60261166","0.6022754","0.60200506","0.6018278","0.6005818","0.5997608","0.5989131","0.59825325","0.59763795","0.5973295","0.5961048","0.5960835","0.5956594","0.5954037","0.5953587","0.59533876","0.59473854","0.5936625","0.5930721","0.59291625","0.5924478","0.5914122","0.5912015","0.59110236","0.5905833","0.59056056","0.590415","0.5903089","0.5898454"],"string":"[\n \"0.73075175\",\n \"0.7227191\",\n \"0.7032894\",\n \"0.70270133\",\n \"0.6928391\",\n \"0.6888921\",\n \"0.6879478\",\n \"0.6835335\",\n \"0.67983305\",\n \"0.665103\",\n \"0.6593733\",\n \"0.6589045\",\n \"0.6541852\",\n \"0.6517649\",\n \"0.6497261\",\n \"0.6496066\",\n \"0.6471588\",\n \"0.64418876\",\n \"0.6415566\",\n \"0.6408056\",\n \"0.6371749\",\n \"0.63470167\",\n \"0.6333958\",\n \"0.6332543\",\n \"0.6329317\",\n \"0.63217056\",\n \"0.63116276\",\n \"0.6291042\",\n \"0.6286879\",\n \"0.62822694\",\n \"0.6280209\",\n \"0.6275323\",\n \"0.62566614\",\n \"0.62566614\",\n \"0.62556756\",\n \"0.6253307\",\n \"0.62506217\",\n \"0.62459886\",\n \"0.6243787\",\n \"0.6238656\",\n \"0.62236696\",\n \"0.6216309\",\n \"0.6216038\",\n \"0.62135446\",\n \"0.621199\",\n \"0.62092113\",\n \"0.62085176\",\n \"0.62084275\",\n \"0.6206367\",\n \"0.62057936\",\n \"0.6202548\",\n \"0.62024385\",\n \"0.61991733\",\n \"0.6183753\",\n \"0.618301\",\n \"0.6165588\",\n \"0.6160859\",\n \"0.61578417\",\n \"0.6156961\",\n \"0.61370033\",\n \"0.61369795\",\n \"0.6132162\",\n \"0.6095926\",\n \"0.6092451\",\n \"0.606533\",\n \"0.6062987\",\n \"0.6060261\",\n \"0.60531044\",\n \"0.6044881\",\n \"0.604445\",\n \"0.6041295\",\n \"0.60327774\",\n \"0.60261166\",\n \"0.6022754\",\n \"0.60200506\",\n \"0.6018278\",\n \"0.6005818\",\n \"0.5997608\",\n \"0.5989131\",\n \"0.59825325\",\n \"0.59763795\",\n \"0.5973295\",\n \"0.5961048\",\n \"0.5960835\",\n \"0.5956594\",\n \"0.5954037\",\n \"0.5953587\",\n \"0.59533876\",\n \"0.59473854\",\n \"0.5936625\",\n \"0.5930721\",\n \"0.59291625\",\n \"0.5924478\",\n \"0.5914122\",\n \"0.5912015\",\n \"0.59110236\",\n \"0.5905833\",\n \"0.59056056\",\n \"0.590415\",\n \"0.5903089\",\n \"0.5898454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":94,"numItemsPerPage":100,"numTotalItems":95772,"offset":9400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDM5ODI2NSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQ0MDE4NjUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.kB14m5Qtxxuv-3Gun771OILqDLYkoxQQLd0KJEwYjvO8ZqVL_B5At1ECuS22AYC9fyksN2h496Xgqz22Xa87Cw","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 |
|---|---|---|---|---|---|---|
Turn all slots of currClusters to zero. | def make_all_zero(curr_clusters, k, num_of_cords):
for i in range(k):
for j in range(num_of_cords):
curr_clusters[i][j] = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _empty_clusters(clusters):\n for clst in clusters:\n clst.points = []",
"def reset(self):\n self._clusters = {}\n self._clusters_val = {}\n self._centroids = {}\n self.store()",
"def zero_cluster():\n if _TRAFFICCTL:\n cmd = _traffic_ctl(\"metric\", \"clear\"... | [
"0.6796202",
"0.64024293",
"0.63158333",
"0.62675047",
"0.6168588",
"0.6164785",
"0.6119265",
"0.60707",
"0.6068551",
"0.6046783",
"0.595144",
"0.5930416",
"0.59281564",
"0.5927291",
"0.59178776",
"0.5910214",
"0.5910083",
"0.5907188",
"0.5899487",
"0.58834374",
"0.585963",
... | 0.74820185 | 0 |
Check if clusters1 equals to clusters2, return True if so, or False if not. | def is_converged(clusters1, clusters2, k, num_of_cords):
for i in range(k):
for j in range(num_of_cords):
if clusters1[i][j] != clusters2[i][j]:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identical_cds(sc1,sc2):\n # Input 2 identical segment chains, return True if cds the same\n if sc1.covers(sc2) and sc2.covers(sc1):\n return True\n else:\n return False",
"def are_clusters_similar(cls, c1, c2, proportion=0.8):\n if len(c1.indices) > len(c2.indices):\n ... | [
"0.6819774",
"0.67053854",
"0.6577482",
"0.6567598",
"0.6566153",
"0.6465101",
"0.6442963",
"0.6380351",
"0.6379164",
"0.6357021",
"0.63215804",
"0.6296718",
"0.62854797",
"0.6203128",
"0.62005913",
"0.61896455",
"0.6144872",
"0.61378944",
"0.6137696",
"0.61299753",
"0.610979... | 0.8044068 | 0 |
Print error message and exit. | def call_error():
print("Error in input format.")
sys.exit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(message):\n print message\n sys.exit(2)",
"def error(msg):\n print 'ERROR: %s' % msg\n sys.exit(1)",
"def ErrorExit(msg):\r\n print >>sys.stderr, msg\r\n sys.exit(1)",
"def print_error_and_exit(error_message):\n\n print(\"Error: \" + error_message)\n sys.exit()",
"def error(ms... | [
"0.8682652",
"0.83133286",
"0.8252245",
"0.81974244",
"0.81944567",
"0.81696945",
"0.8102151",
"0.80890137",
"0.80763304",
"0.8058573",
"0.8032233",
"0.8027259",
"0.8015662",
"0.799886",
"0.79149866",
"0.78957844",
"0.78918314",
"0.7880633",
"0.78051",
"0.78021055",
"0.774882... | 0.7875015 | 18 |
Print the coordinates as needed for the exercise. | def print_final_res(res, k, num_of_cords):
for t in range(k):
for p in range(num_of_cords):
counter = 1
num = str(float("{:.4f}".format(res[t][p]))).split(".")
integ = list(map(str, num[0]))
frac = list(map(int, num[1]))
for digit in integ:
if digit == "-":
print(digit, end="")
elif counter <= 5:
print(int(digit), end="")
counter += 1
if counter <= 5:
print(".", end="")
for digit in frac:
if counter <= 5:
print(digit, end="")
counter += 1
while counter <= 5:
print(0, end="")
counter += 1
if p == num_of_cords-1:
print("")
else:
print(",", end="") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_my_coords(x = 0, y = 0):\n\tprint(\"Coords (%d;%d)\" % (x,y))",
"def display(self):\n \"\"\" Coordinates for position are x-axis (LR) and y-axis (NS) \"\"\"\n for coordY in range(self.y):\n print()\n for column in range(self.height):\n for coordLR in range(sel... | [
"0.7668902",
"0.72341406",
"0.6983642",
"0.68224555",
"0.6820623",
"0.6797979",
"0.6736476",
"0.6682067",
"0.66407675",
"0.6639759",
"0.6600853",
"0.65653497",
"0.6540607",
"0.6519379",
"0.6514798",
"0.64698935",
"0.6465841",
"0.64637744",
"0.64516777",
"0.64497644",
"0.64263... | 0.0 | -1 |
Given batch of anchor descriptors and positive descriptors calculate euclidean distance matrix | def distance_matrix_vector(anchor, positive):
# here anchor*anchor is equal torch.mul(anchor, anchor)
# the element-wise value multiplication is returned
d1_sq = torch.sum(anchor * anchor, dim=1).unsqueeze(-1)
d2_sq = torch.sum(positive * positive, dim=1).unsqueeze(-1)
eps = 1e-6
# tensor.repeat(): repeat at each dims, and dims from right to left
return torch.sqrt((d1_sq.repeat(1, anchor.size(0)) + torch.t(d2_sq.repeat(1, positive.size(0)))
- 2.0 * torch.bmm(anchor.unsqueeze(0), torch.t(positive).unsqueeze(0)).squeeze(0))
+eps) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _derive_euclidean_dm(self, cat_mat, dim):\r\n res_mat = []\r\n\r\n for i in range(dim):\r\n res_mat.append([0 for k in range(dim)])\r\n for j in range(i):\r\n res_mat[i][j] = self._vector_dist(cat_mat[i], cat_mat[j])\r\n res_mat[j][i] = res_mat[... | [
"0.661237",
"0.65518934",
"0.65397006",
"0.636195",
"0.6311224",
"0.6290709",
"0.6187235",
"0.61502486",
"0.61339396",
"0.61114454",
"0.61069995",
"0.6097225",
"0.6097225",
"0.6093995",
"0.6067778",
"0.6055344",
"0.6040386",
"0.6026841",
"0.60233694",
"0.6018614",
"0.6015458"... | 0.60668904 | 15 |
Given batch of anchor descriptors and positive descriptors calculate distance matrix The distance metric is Euclidean distance L2dist | def distance_vectors_pairwise(anchor, positive, negative):
a_sq = torch.sum(anchor * anchor, dim=1)
p_sq = torch.sum(positive * positive, dim=1)
n_sq = torch.sum(negative * negative, dim=1)
eps = 1e-8
d_a_p = torch.sqrt(a_sq + p_sq - 2*torch.sum(anchor * positive, dim = 1) + eps)
d_a_n = torch.sqrt(a_sq + n_sq - 2*torch.sum(anchor * negative, dim = 1) + eps)
d_p_n = torch.sqrt(p_sq + n_sq - 2*torch.sum(positive * negative, dim = 1) + eps)
return d_a_p, d_a_n, d_p_n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_l2_distance_matrix(features_queries, features_dataset):\n sx = np.sum(features_queries ** 2, axis=1, keepdims=True)\n sy = np.sum(features_dataset ** 2, axis=1, keepdims=True)\n\n return np.sqrt(-2 * features_queries.dot(features_dataset.T) + sx + sy.T)",
"def distance(self, features, target... | [
"0.6684549",
"0.6541754",
"0.6541754",
"0.6529875",
"0.64755595",
"0.64498234",
"0.6433003",
"0.64293146",
"0.6418028",
"0.6330827",
"0.6323023",
"0.6297623",
"0.62218076",
"0.6159287",
"0.6140069",
"0.6132013",
"0.6113837",
"0.6111654",
"0.61090785",
"0.6100563",
"0.60982287... | 0.5747658 | 69 |
Loss with random sampling (no hard in batch). | def loss_random_sampling(anchor, positive, negative, anchor_swap = False, margin = 1.0, loss_type = "triplet_margin"):
assert anchor.size() == positive.size(), "Input sizes between positive and negative must be equal."
assert anchor.size() == negative.size(), "Input sizes between positive and negative must be equal."
assert anchor.dim() == 2, "Inputd must be a 2D matrix."
eps = 1e-8
(pos, d_a_n, d_p_n) = distance_vectors_pairwise(anchor, positive, negative)
# distance based anchor, if anchor swap, get the min(anchor, positive)
if anchor_swap:
min_neg = torch.min(d_a_n, d_p_n)
else:
min_neg = d_a_n
if loss_type == "triplet_margin":
# the func is (m + D_p - D_n)
loss = torch.clamp(margin + pos - min_neg, min=0.0)
elif loss_type == 'softmax':
# here the output is 2-class log-softmax loss(1/0) from L2Net
exp_pos = torch.exp(2.0 - pos)
exp_den = exp_pos + torch.exp(2.0 - min_neg) + eps
loss = - torch.log( exp_pos / exp_den )
elif loss_type == 'contrastive':
loss = torch.clamp(margin - min_neg, min=0.0) + pos
else:
print ('Unknown loss type. Try triplet_margin, softmax or contrastive')
sys.exit(1)
loss = torch.mean(loss)
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_loss_orig(self, noise_samples):\n generator_samples = self.gen_model(noise_samples)\n logits_gen = self.disc_model(generator_samples)\n # loss = -tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros(logits_gen.shape), logits=logits_gen))\n loss = tf.reduce_mean... | [
"0.6654641",
"0.6595753",
"0.65544915",
"0.64899355",
"0.6487611",
"0.6350678",
"0.63220733",
"0.62942404",
"0.6251492",
"0.62248963",
"0.61995137",
"0.61536497",
"0.61419076",
"0.6131341",
"0.6121647",
"0.6115955",
"0.6109206",
"0.60922635",
"0.6075736",
"0.6044063",
"0.6037... | 0.5773103 | 79 |
HardNet margin loss calculates loss based on distance matrix based on positive distance and closest negative distance. | def loss_HardNet(anchor, positive, anchor_swap = False, anchor_ave = False,
margin = 1.0, batch_reduce = 'min', loss_type = "triplet_margin"):
assert anchor.size() == positive.size(), "Input sizes between positive and negative must be equal."
assert anchor.dim() == 2, "Inputd must be a 2D matrix."
eps = 1e-8
dist_matrix = distance_matrix_vector(anchor, positive) +eps # D = A_t*P
eye = torch.autograd.Variable(torch.eye(dist_matrix.size(1))).cuda()
# steps to filter out same patches that occur in distance matrix as negatives
pos1 = torch.diag(dist_matrix)
dist_without_min_on_diag = dist_matrix+eye*10
# get all the indices which value<0.008
mask = (dist_without_min_on_diag.ge(0.008).float()-1.0)*(-1)
mask = mask.type_as(dist_without_min_on_diag)*10
dist_without_min_on_diag = dist_without_min_on_diag+mask
# sampling strategy of Hardest in batch
if batch_reduce == 'min':
# mining the value < 0.008(without mining on the diagonal)
min_neg = torch.min(dist_without_min_on_diag, 1)[0]
if anchor_swap:
min_neg2 = torch.min(dist_without_min_on_diag, 0)[0]
min_neg = torch.min(min_neg, min_neg2)
""" print for debug
dist_matrix_a = distance_matrix_vector(anchor, anchor)+ eps
dist_matrix_p = distance_matrix_vector(positive,positive)+eps
dist_without_min_on_diag_a = dist_matrix_a+eye*10
dist_without_min_on_diag_p = dist_matrix_p+eye*10
min_neg_a = torch.min(dist_without_min_on_diag_a,1)[0]
min_neg_p = torch.t(torch.min(dist_without_min_on_diag_p,0)[0])
min_neg_3 = torch.min(min_neg_p,min_neg_a)
min_neg = torch.min(min_neg,min_neg_3)
print (min_neg_a)
print (min_neg_p)
print (min_neg_3)
print (min_neg)
"""
min_neg = min_neg
pos = pos1
elif batch_reduce == 'average':
# why repeat pos value here?
pos = pos1.repeat(anchor.size(0)).view(-1,1).squeeze(0)
min_neg = dist_without_min_on_diag.view(-1,1)
if anchor_swap:
min_neg2 = torch.t(dist_without_min_on_diag).contiguous().view(-1,1)
# compare anchor-pos vs. pos-anchor value
min_neg = torch.min(min_neg, min_neg2)
min_neg = min_neg.squeeze(0)
elif batch_reduce == 'random':
idxs = torch.autograd.Variable(torch.randperm(anchor.size()[0]).long()).cuda()
min_neg = dist_without_min_on_diag.gather(1, idxs.view(-1,1))# dim=1, col-idx
if anchor_swap:
min_neg2 = torch.t(dist_without_min_on_diag).gather(1,idxs.view(-1,1))
min_neg = torch.min(min_neg, min_neg2)
min_neg = torch.t(min_neg).squeeze(0)
pos = pos1
else:
print ('Unknown batch reduce mode. Try min, average or random')
sys.exit(1)
# calculate the loss depends on the loss_type
if loss_type == "triplet_margin":
loss = torch.clamp(margin + pos - min_neg, min=0.0)
elif loss_type == 'softmax':
# Softmin used here: (-x) instead of x as the input
# log-likelihood cost function instead of cross-entropy cost function
exp_pos = torch.exp(2.0 - pos)
exp_den = exp_pos + torch.exp(2.0 - min_neg) + eps
loss = - torch.log( exp_pos / exp_den )
elif loss_type == 'contrastive':
loss = torch.clamp(margin - min_neg, min=0.0) + pos
else:
print ('Unknown loss type. Try triplet_margin, softmax or contrastive')
sys.exit(1)
loss = torch.mean(loss)
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TripletSemiHardLoss(y_true, y_pred, device, margin=1.0):\n\n labels, embeddings = y_true, y_pred\n\n # Reshape label tensor to [batch_size, 1].\n lshape = labels.shape\n labels = torch.reshape(labels, [lshape[0], 1])\n\n pdist_matrix = pairwise_distance_torch(embeddings, device)\n\n # Build p... | [
"0.6751771",
"0.66457057",
"0.6491428",
"0.6382015",
"0.63105524",
"0.62775844",
"0.627555",
"0.6233407",
"0.61440635",
"0.61312664",
"0.61160314",
"0.6053419",
"0.5984343",
"0.5938494",
"0.5920994",
"0.587004",
"0.58658993",
"0.58524287",
"0.5841395",
"0.5838248",
"0.5798553... | 0.61158264 | 11 |
Retrieve an exchange from database by id | def get_exchange(self, id):
return self.exch_repo.get(id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getbyid(self, id):\n\n return esd.retrieve(id)",
"def get(self, _id):",
"def read_item(id: str, request: Request):\n obj = db.get(id, kind=endpoint_model)\n return obj",
"def get(cls, id):\n\n return cls.query.get(id)",
"def get(cls, id):\n\n return cls.query.get(id)"... | [
"0.67121446",
"0.657574",
"0.6478656",
"0.64241445",
"0.64241445",
"0.6390948",
"0.6356077",
"0.63458675",
"0.6295548",
"0.6249574",
"0.6248896",
"0.62442577",
"0.61988556",
"0.61408186",
"0.6100281",
"0.6074537",
"0.6065128",
"0.606222",
"0.6061581",
"0.6003485",
"0.5983606"... | 0.80811805 | 0 |
Retrieve exchanges from database | def get_exchanges(self, search_criteria):
return self.exch_repo.getList(search_criteria=search_criteria) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_exchanges(self):\n self.logger.debug(\"Fetching exchanges.\")\n return self._api_query(\"exchanges\")['exchanges']",
"def _get_exchanges(token: str) -> List[mtypes.Exchange]:\n _LOG.info(\"Getting exchanges from API ...\")\n response = get_client().service.ExchangeList(Token=token)\n\... | [
"0.7162192",
"0.6780117",
"0.6251137",
"0.62181497",
"0.6184577",
"0.60228324",
"0.5948971",
"0.5887415",
"0.58758724",
"0.5803503",
"0.57923263",
"0.57165515",
"0.5698509",
"0.5664619",
"0.56348133",
"0.5599414",
"0.55822587",
"0.5546716",
"0.55274445",
"0.5524719",
"0.54852... | 0.6667094 | 2 |
List all exchanges or one exchange if id option is given | def list_exchanges(self, search_criteria=None):
if search_criteria is None:
search_criteria = {}
exchanges = self.get_exchanges(search_criteria)
for exchange in exchanges:
self.print_exchange(exchange) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_exchange(self, id):\n return self.exch_repo.get(id)",
"def _get_exchanges(token: str) -> List[mtypes.Exchange]:\n _LOG.info(\"Getting exchanges from API ...\")\n response = get_client().service.ExchangeList(Token=token)\n\n exchanges = [\n mtypes.Exchange.from_dict(d=obj)\n ... | [
"0.6209942",
"0.564042",
"0.54858893",
"0.54477894",
"0.54447",
"0.5443821",
"0.54165643",
"0.52149",
"0.5213143",
"0.51882815",
"0.5044624",
"0.49607393",
"0.4930922",
"0.4921522",
"0.4893471",
"0.48433566",
"0.48054418",
"0.4801602",
"0.4760806",
"0.47593036",
"0.47506058",... | 0.55560803 | 2 |
Create a new exchange in the database | def create_exchange(self, exchangename, public_key, private_key, user_id, uid = None, pw = None):
if not exchangename or not public_key or not private_key:
raise Exception("Exchangename, public key and private key must be given")
else:
return self.exch_repo.create(exchangename, public_key, private_key, user_id, uid, pw) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_exchange(self, exchange_name, exchange_type, internal=None):\n self._channel.exchange_declare(\n exchange=exchange_name,\n durable=True, # Survive reboot\n passive=False, # Perform a declare or just to see if it exists\n internal=internal, # Can only... | [
"0.6696044",
"0.6593915",
"0.6464137",
"0.6299332",
"0.6108338",
"0.6079601",
"0.605643",
"0.60084194",
"0.5968516",
"0.5955321",
"0.5955321",
"0.5921751",
"0.58424836",
"0.579992",
"0.57557315",
"0.57557315",
"0.57557315",
"0.57540107",
"0.569132",
"0.56544197",
"0.5631779",... | 0.7036039 | 0 |
Delete an existing exchange from the database | def delete_exchange(self, exchange_id):
if exchange_id:
self.exch_repo.delete(exchange_id=exchange_id)
else:
raise Exception("No exchange_id found for deleting exchange.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_exchange(self):\n new_exchange = self.app.add_exchange(\"test\", \"test\", \"test\")\n ret = self.app.delete_exchange(new_exchange.id)\n self.assertIn(ret[0], \"success\")",
"def test_delete_exchange_not_exists(self):\n ret = self.app.delete_exchange(20)\n self.... | [
"0.77815914",
"0.6905101",
"0.6586099",
"0.62237895",
"0.61273843",
"0.6105402",
"0.6093326",
"0.60743785",
"0.607348",
"0.6057913",
"0.6057913",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.60360014",
"0.6... | 0.74982965 | 1 |
Checks if an input pair is a valid one for given exchange | def is_valid_pair(self, pair, exchange):
pairs = self.ccxt.get_pairs(exchange)
print(pairs)
return pair in pairs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_pairs(pairs, historical_pairs):\n if pairs is None:\n return False\n for p in pairs:\n if p in historical_pairs:\n return False\n return True",
"def is_exchange_information_valid(exchange_info: Dict[str, Any]) -> bool:\n return exchange_info.get(\"status\", None)... | [
"0.6861681",
"0.6571933",
"0.6249077",
"0.6183069",
"0.6036506",
"0.5871636",
"0.5846162",
"0.5783997",
"0.5700833",
"0.56721383",
"0.5660363",
"0.5637686",
"0.5573187",
"0.5572298",
"0.5558149",
"0.5551392",
"0.55479705",
"0.55122805",
"0.5481704",
"0.5452177",
"0.53962547",... | 0.8063874 | 0 |
Fetches balance for a pair on an exchange through CCXT | def fetch_balance(self, exchange, pair):
return self.ccxt.fetch_balance(exchange, pair) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def fetch_balance(self, params={}):\n await self.load_markets()\n request = {\n 'currency': 'all',\n }\n response = await self.privateGetUserMargin(self.extend(request, params))\n #\n # [\n # {\n # \"account\":1455728,... | [
"0.7030547",
"0.68978024",
"0.68687195",
"0.67780674",
"0.6721376",
"0.64743924",
"0.64189506",
"0.6408955",
"0.63560534",
"0.6347745",
"0.63321614",
"0.6328665",
"0.6324221",
"0.6236682",
"0.6235676",
"0.6205206",
"0.61926544",
"0.61854434",
"0.6158296",
"0.6154335",
"0.6130... | 0.85180926 | 0 |
Retrieves the trading fee for a certain pair on a certain exchange | def get_exchange_trading_fee(self, exchange, pair, type):
return self.ccxt.get_exchange_trading_fee(exchange, pair, type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fee(self, pair, order_type):\n fees = self.p_state._getvalue()['fees']\n if fees:\n\n return float(fees[self._handler[order_type]][pair]['fee'])\n\n else:\n\n return 0.0",
"def get_price(self, pair='XBTZAR'):\n data = {'pair': pair}\n query_string ... | [
"0.72088563",
"0.6718482",
"0.6621101",
"0.64627856",
"0.6384671",
"0.630662",
"0.6283862",
"0.6246754",
"0.62267923",
"0.6090204",
"0.59220403",
"0.59198195",
"0.58899343",
"0.58853585",
"0.58453304",
"0.58343554",
"0.5809528",
"0.5797195",
"0.5788672",
"0.5771605",
"0.57653... | 0.8056572 | 0 |
Retrieves the market price for a certain pair on a certain exchange for a certain type(maker or taker) | def get_market_price(self, exchange, pair, type):
return self.ccxt.get_market_price(exchange, pair, type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_price(self, pair='XBTZAR'):\n data = {'pair': pair}\n query_string = build_query_string(data)\n\n r = requests.get(build_api_call(self.base_url, None, 'ticker', query_string))\n if r.status_code == 200:\n return r.json()",
"def get_price(horizon_host, pair):\n pr... | [
"0.7793075",
"0.69196445",
"0.67033094",
"0.6688754",
"0.6671473",
"0.66665936",
"0.6616699",
"0.6557316",
"0.6485801",
"0.6459023",
"0.6424058",
"0.6368259",
"0.633056",
"0.63264066",
"0.6295311",
"0.62687165",
"0.626795",
"0.62592244",
"0.6171922",
"0.6159443",
"0.60960245"... | 0.8632258 | 0 |
Place an order through the ccxt library for a certain exchange, for a certain pair (BTC/USD), type as buy/sell, and amount in currency (if BTC/USD will be BTC) | def place_order(self, exchange, pair, type, amount, price = None):
return self.ccxt.place_order(exchange, pair, type, amount, price) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def buy(self, trading_pair: str, amount: Decimal, order_type: OrderType, price: Decimal) -> str:\n return self.place_order(True, trading_pair, amount, price)",
"async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):\n await self.load_markets()\n ... | [
"0.71927655",
"0.7107266",
"0.7054423",
"0.6819442",
"0.6688734",
"0.66799307",
"0.66651535",
"0.6650478",
"0.6600853",
"0.6514789",
"0.65064514",
"0.64885443",
"0.6481737",
"0.6471577",
"0.6377945",
"0.6365583",
"0.6359703",
"0.63556045",
"0.6327038",
"0.6295299",
"0.6267949... | 0.76989853 | 0 |
Cancel the order through ccxt library for a certain exchange | def cancel_order(self, exchange, order_id):
return self.ccxt.cancel_order(exchange, order_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_cancel(order):\r\n self.gox.cancel(order.oid)",
"def cancelOrder(self, order_number):\n pass",
"def _order_cancel(self, bo):\n log.info(\"bo_blotter: order_cancel bracket order bo#%s\" % bo.ticket) \n cancelled = bo.cancel()\n return(cancelled)",
"def canc... | [
"0.7706166",
"0.744995",
"0.7211225",
"0.70317745",
"0.6936221",
"0.6923826",
"0.6887567",
"0.68759936",
"0.6835702",
"0.6832168",
"0.68217963",
"0.6820352",
"0.68094903",
"0.67458665",
"0.6741805",
"0.67316127",
"0.6710419",
"0.67094696",
"0.66826385",
"0.6623428",
"0.65751"... | 0.75702757 | 1 |
Get the the data for a certain exchange for a given pair for the last 700 hours | def get_history_data(self, exchange, pair, timedelta):
return self.ccxt.get_history_data(exchange, pair, timedelta) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(pair, other):\n days_ago = 7\n endtime = int(time())\n starttime = endtime - 60 * 60 * 24 * days_ago\n\n geckourl = '%s/markets?vs_currency=%s&ids=%s' % (API, pair[\"currency\"],\n pair[\"coin\"])\n liveprice = requests.get(geckourl).j... | [
"0.6836399",
"0.627741",
"0.6234868",
"0.62244236",
"0.61926",
"0.6124068",
"0.605874",
"0.60258263",
"0.5984681",
"0.5967804",
"0.57844293",
"0.5726083",
"0.57112515",
"0.5710812",
"0.5707336",
"0.5707336",
"0.569271",
"0.56634426",
"0.5589972",
"0.5550989",
"0.55486476",
... | 0.68828434 | 0 |
Discovers a footprint object from a DFG | def apply(dfg, parameters=None):
if parameters is None:
parameters = {}
parallel = {(x, y) for (x, y) in dfg if (y, x) in dfg}
sequence = {(x, y) for (x, y) in dfg if not (y, x) in dfg}
# replace this if needed
start_activities = set(utils.dfg_utils.infer_start_activities(dfg))
# replace this if needed
end_activities = set(utils.dfg_utils.infer_end_activities(dfg))
activities = set(utils.dfg_utils.get_activities_from_dfg(dfg))
return {Outputs.SEQUENCE.value: sequence, Outputs.PARALLEL.value: parallel,
Outputs.START_ACTIVITIES.value: start_activities, Outputs.END_ACTIVITIES.value: end_activities, Outputs.ACTIVITIES.value: activities} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mgrs_footprint(mgrs_id):\n\n gzd = mgrs_id[:3]\n\n mgrs_100km_gzd = mgrs_id[3:]\n print(gzd)\n print(mgrs_100km_gzd)\n\n file_path = unzip_mgrs_shapefile(gzd)\n\n shapefile_driver = ogr.GetDriverByName(\"ESRI Shapefile\")\n\n grid_ds = shapefile_driver.Open(str(file_path), 0)\n\n la... | [
"0.5391321",
"0.5379075",
"0.52517396",
"0.5143941",
"0.51311654",
"0.5087027",
"0.5060385",
"0.5049106",
"0.5047882",
"0.5021228",
"0.5005856",
"0.4988447",
"0.49569166",
"0.4952292",
"0.4878632",
"0.48658168",
"0.47970238",
"0.47567862",
"0.47346526",
"0.47303435",
"0.47240... | 0.0 | -1 |
Used for loading in model and word2vec files from disk. Returns their objects. | def LoadSavedModels(main_model_path="main_model.pkl",
cler_model_path="cler_model.pkl",
word2vec_path='GoogleNews-vectors-negative300.bin'):
model_main = joblib.load(main_model_path)
model_cler = joblib.load(cler_model_path)
word2vec = gensim.models.KeyedVectors.load_word2vec_format(word2vec_path, binary=True)
return model_main,model_cler,word2vec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_vectors(path, to_train=False):\n model = Word2Vec.load(path)\n\n if to_train:\n return model\n\n # In case it doesn't need to be trained, delete train code to free up ram\n word_vectors = model.wv\n\n context_vectors = dict()\n if hasattr(model, \"syn1\... | [
"0.69597363",
"0.6947155",
"0.6811197",
"0.6807579",
"0.6805793",
"0.6797359",
"0.6768113",
"0.6706945",
"0.65690553",
"0.6520081",
"0.6514057",
"0.6461425",
"0.6448351",
"0.64457756",
"0.64116144",
"0.64102066",
"0.6408863",
"0.63833255",
"0.63704264",
"0.6347624",
"0.634755... | 0.7026279 | 0 |
Predict a label using the main model (clinical, clerical or other). Input is a sentence, along w/ model object and word2vec object. These objects can either be loaded from disk using the LoadSavedModels function, or, if you have just completed training, they can be passed in from the Train.Trainer class. May also adjust the probability threshold above which a clerical decision is made (good for reducing false positives). 0.98 makes for very few false positives! | def PredictLabel(sentence, model_main, word2vec, boundary=0.5):
tokenized_sample = word_tokenize(re.sub("-"," ",sentence))
features = np.mean([word2vec.word_vec(w) for w in tokenized_sample if w in word2vec],axis=0)
prediction = model_main.predict_proba(features.reshape(1,-1))[0]
if model_main.classes_[prediction.argmax()]!="clerical":
return model_main.classes_[prediction.argmax()]
else:
if np.max(prediction)>boundary:
return "clerical"
else:
ranger = range(len(prediction))
del ranger[prediction.argmax()]
return model_main.classes_[ranger][prediction[ranger].argmax()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PredictClerLabel(sentence, model_cler, word2vec):\n \n tokenized_sample = word_tokenize(re.sub(\"-\",\" \",sentence))\n features = np.mean([word2vec.word_vec(w) for w in tokenized_sample if w in word2vec],axis=0)\n prediction = model_cler.predict_proba(features.reshape(1,-1))[0]\n return model_c... | [
"0.6959012",
"0.65132445",
"0.65114045",
"0.6501456",
"0.6449135",
"0.6394472",
"0.6369494",
"0.6363786",
"0.63258064",
"0.63060385",
"0.62783635",
"0.62781966",
"0.6276569",
"0.6266087",
"0.62624",
"0.61981785",
"0.61941963",
"0.61721903",
"0.6151807",
"0.6150158",
"0.613657... | 0.7438309 | 0 |
Predict a label use the clerical model. Input is a sentence, along w/ model object and word2vec object. These objects can either be loaded from disk using the LoadSavedModels function, or, if you have just completed training, they can be passed in from the Train.Trainer class. | def PredictClerLabel(sentence, model_cler, word2vec):
tokenized_sample = word_tokenize(re.sub("-"," ",sentence))
features = np.mean([word2vec.word_vec(w) for w in tokenized_sample if w in word2vec],axis=0)
prediction = model_cler.predict_proba(features.reshape(1,-1))[0]
return model_cler.classes_[prediction.argmax()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PredictLabel(sentence, model_main, word2vec, boundary=0.5):\n \n tokenized_sample = word_tokenize(re.sub(\"-\",\" \",sentence))\n features = np.mean([word2vec.word_vec(w) for w in tokenized_sample if w in word2vec],axis=0)\n prediction = model_main.predict_proba(features.reshape(1,-1))[0]\n if m... | [
"0.6949452",
"0.6697954",
"0.6614793",
"0.65763474",
"0.6551022",
"0.65021735",
"0.6459889",
"0.6424772",
"0.64095986",
"0.63946915",
"0.6354461",
"0.6343086",
"0.6327474",
"0.62942815",
"0.62706435",
"0.6258738",
"0.6226277",
"0.62202674",
"0.62170017",
"0.62144226",
"0.6206... | 0.7439432 | 0 |
Load IMITS data into a given Spark Context. | def extract_imits(spark_session: SparkSession) -> DataFrame:
print(spark_session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSparkContext():\n conf = (SparkConf()\n .setMaster(\"local\") # run on local\n .setAppName(\"Logistic Regression\") # Name of App\n .set(\"spark.executor.memory\", \"1g\")) # Set 1 gig of memory\n sc = SparkContext(conf = conf) \n return sc",
"def __init__(self, spark_sess... | [
"0.60987294",
"0.5617119",
"0.5612132",
"0.5608199",
"0.5594259",
"0.5567496",
"0.5528342",
"0.5485825",
"0.5481655",
"0.53868705",
"0.531229",
"0.5279974",
"0.52767175",
"0.5239063",
"0.5228245",
"0.517938",
"0.51645696",
"0.51608706",
"0.51583445",
"0.51293147",
"0.50806874... | 0.5426127 | 9 |
plots the fenics mesh as it is | def plot_fenics_mesh(mesh, new_fig=True):
if(new_fig):
plt.figure()
plot(mesh)
#plt.title("FEniCS mesh")
plt.show(block=False)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_plot_mesh(self):\n plt.close('all')\n\n #\n # Initialize\n #\n fig, ax = plt.subplots(3,3)\n plot = Plot()\n #\n # Define mesh\n # \n mesh = Mesh.newmesh(grid_size=(2,2))\n mesh.refine() \n mesh.root_node().children[1... | [
"0.7348052",
"0.7272838",
"0.7201923",
"0.71683663",
"0.6932882",
"0.6908609",
"0.68675065",
"0.6819857",
"0.67012626",
"0.66765225",
"0.66062456",
"0.6585177",
"0.65265316",
"0.6516479",
"0.6515228",
"0.6511229",
"0.6509004",
"0.643969",
"0.64123374",
"0.6407074",
"0.6393894... | 0.7717216 | 0 |
plots the mesh/centroids of mesh as is expected in peridynamics either mesh or cell_cent is to be provided by user neither provinding mesh nor providing cell_cent is wrong | def plot_peridym_mesh(mesh=None, struct_grd=True, cell_cent=None, disp_cent=None, annotate=False):
if struct_grd:
cell_centroid_function = structured_cell_centroids
else:
cell_centroid_function = get_cell_centroids
if mesh == None and len(np.shape(cell_cent)) == 0 and len(np.shape(disp_cent)) == 0:
raise AssertionError("provide either fenics mesh or cell centroid of PD particles")
if len(np.shape(cell_cent)) != 0 and len(np.shape(disp_cent))==0:
extents = get_domain_bounding_box(cell_cent=cell_cent)
if len(np.shape(cell_cent)) == 0 and len(np.shape(disp_cent))!=0:
extents = get_domain_bounding_box(cell_cent=disp_cent)
if mesh != None and (len(np.shape(cell_cent)) == 0 and len(np.shape(disp_cent)) == 0):
extents = get_domain_bounding_box(mesh=mesh)
cell_cent = cell_centroid_function(mesh)
## we wish to scale the axis accordign to geometry
dim = len(cell_cent[0])
x_min = extents[0][0]; x_max = extents[1][0]
y_min = extents[0][1]; y_max = extents[1][1]
x=None; y=None; z=None
fig = plt.figure()
if dim == 3:
z_min = corners[0][2]; z_max = corners[1][2]
x,y,z = cell_cent.T
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x,y,z, s=70, marker='o', color='b', alpha=1.0, edgecolors='face')
ax.axis('off')
if dim == 2 :
ax = fig.add_subplot(111)
x,y = cell_cent.T
plt.scatter(x,y, s=300, color='b', marker='o', alpha=0.6)
plt.axis=('off')
if annotate==True:
for idx, cc in enumerate(cell_cent):
plt.text(cc[0], cc[1], str(idx), color='k', verticalalignment='bottom', horizontalalignment='right', fontsize='medium')
ax.set_aspect('equal')
plt.title("peridynamics mesh")
plt.show(block=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_plot_mesh(self):\n plt.close('all')\n\n #\n # Initialize\n #\n fig, ax = plt.subplots(3,3)\n plot = Plot()\n #\n # Define mesh\n # \n mesh = Mesh.newmesh(grid_size=(2,2))\n mesh.refine() \n mesh.root_node().children[1... | [
"0.6864378",
"0.6407954",
"0.6205415",
"0.61812276",
"0.61798674",
"0.60916793",
"0.609019",
"0.60803694",
"0.60406137",
"0.59588164",
"0.59557277",
"0.59142935",
"0.58919984",
"0.58745694",
"0.58541936",
"0.5786406",
"0.57543874",
"0.5720695",
"0.5686189",
"0.5673838",
"0.56... | 0.7505498 | 0 |
plots the displaced cell centroids after a solution step. Additionally retrns the final cell centroid after additon of displacement field in the orginal configuration | def get_displaced_soln(cell_cent, u_disp, horizon, dim, data_dir=None, plot_=False, save_fig=False, zoom=40):
disp_cent = cell_cent + u_disp
if plot_ or save_fig:
dpi = 2
legend_size = {'size': str(6*dpi)}
fig = plt.figure()
if dim == 2:
ax = fig.add_subplot(111)
x, y = cell_cent.T
#plt.scatter(x,y, s=300, color='r', marker='o', alpha=0.1, label='original config')
x,y = (cell_cent + zoom*u_disp).T
plt.scatter(x,y, s=150, color='b', marker='o', alpha=0.6, label=r'$\delta$ = '+ format(horizon, '4.5g'))
# plt.legend(prop=legend_size)
#plt.xlim(x_min - fact*x_min, x_max + fact*x_max)
#plt.ylim(y_min - fact*y_min, y_max + fact*y_max)
if dim == 3:
#z_min = corners[0][2]; z_max = corners[1][2]
from mpl_toolkits.mplot3d import Axes3D
x, y, z = cell_cent.T
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x,y,z, s=150, color='r', marker='o', alpha=0.1, label='original config')
x,y,z = (cell_cent + zoom*u_disp)
ax.scatter(x,y,z,s=150, color='g', marker='o', alpha=1.0, label='deformed config')
ax.axis('off')
plt.legend()
ax.set_aspect('equal')
if plot_:
plt.show(block=False)
if save_fig:
plt.savefig(data_dir)
plt.close(fig)
return disp_cent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plotcenterrange():\n plist1 = np.arange(0.02,0.1,0.02)\n plist = np.arange(0.1,1,0.1)\n infectlist = []\n for i in plist1:\n infectlist.append(checkinfectb(0.5,20000,30,200,p = i,q = np.sqrt(2/(20000*math.pi)),startcenter=True)[0])\n for i in plist:\n infectlist.append(checkinfectb... | [
"0.61388534",
"0.6034441",
"0.58881974",
"0.5873742",
"0.58667403",
"0.58461356",
"0.5768717",
"0.5750362",
"0.56975144",
"0.5666557",
"0.5653945",
"0.56459886",
"0.5611346",
"0.558924",
"0.55840623",
"0.5583146",
"0.55808353",
"0.5573108",
"0.5564739",
"0.5562984",
"0.553712... | 0.63715124 | 0 |
generates a triangulated Rectangular domain with a circular hole input | def rectangle_mesh(point1=Point(0,0), point2=Point(2,1), numptsX=10, numptsY=5):
mesh = RectangleMesh(point1, point2, numptsX, numptsY )
print_mesh_stats(mesh)
return mesh | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRing(ri, ro, size=(25, 25)):\n n, m = size\n xs, ys = np.mgrid[-1:1:n * 1j, -1:1:m * 1j]\n r = np.sqrt(xs ** 2 + ys ** 2)\n\n torus = np.zeros(size, dtype=np.uint8)\n torus[(r < ro) & (r > ri)] = 1\n return torus",
"def to_circular(self):\n return quad_hybrid.dot(self.linear)",
"def... | [
"0.6168527",
"0.5892623",
"0.5813818",
"0.57707417",
"0.5706577",
"0.55293894",
"0.5516006",
"0.5515859",
"0.54446626",
"0.54344803",
"0.5432176",
"0.5431236",
"0.5403426",
"0.54032457",
"0.5320207",
"0.5309659",
"0.52998513",
"0.5279193",
"0.5279193",
"0.5275167",
"0.5263225... | 0.0 | -1 |
generates a triangulated Rectangular domain with a circular hole input | def rectangle_mesh_with_hole(point1=Point(0,0), point2=Point(3,1), hole_cent=Point(1.5,0.5),
hole_rad=0.25, npts=15):
Router = mshr.Rectangle(point1, point2)
Rinner = mshr.Circle(hole_cent, hole_rad)
domain = Router - Rinner
mesh = mshr.generate_mesh(domain, npts)
print_mesh_stats(mesh)
return mesh | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRing(ri, ro, size=(25, 25)):\n n, m = size\n xs, ys = np.mgrid[-1:1:n * 1j, -1:1:m * 1j]\n r = np.sqrt(xs ** 2 + ys ** 2)\n\n torus = np.zeros(size, dtype=np.uint8)\n torus[(r < ro) & (r > ri)] = 1\n return torus",
"def to_circular(self):\n return quad_hybrid.dot(self.linear)",
"def... | [
"0.6168527",
"0.5892623",
"0.5813818",
"0.57707417",
"0.5706577",
"0.55293894",
"0.5516006",
"0.5515859",
"0.54344803",
"0.5432176",
"0.5431236",
"0.5403426",
"0.54032457",
"0.5320207",
"0.5309659",
"0.52998513",
"0.5279193",
"0.5279193",
"0.5275167",
"0.52632254",
"0.5257246... | 0.54446626 | 8 |
creates a structured cell centroids and cell volumes of square or cubic lattice using the fenics mesh by averaging appropriate number of 2D/3D triangles | def structured_cell_centroids(mesh):
dim = mesh.topology().dim()
stride = fact(dim)
cents = get_cell_centroids(mesh)
num_cells = int(mesh.num_cells()/stride)
cell_cents_struct = np.zeros((num_cells,dim),dtype=float)
for i in range(num_cells):
start = int(stride*i)
end = int(stride*i)+stride
cell_cents_struct[i] = np.average(cents[start:end],axis=0)
return cell_cents_struct | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cfdProcessGeometry(self):\r\n \r\n # self.faceCentroids']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceSf']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceAreas']= [[] for i in range(self.numberOfFaces'])]\r\n \r\n ## Linear weight of distance from cel... | [
"0.7054485",
"0.6528232",
"0.64348644",
"0.6230865",
"0.61347985",
"0.61224085",
"0.60659236",
"0.6059065",
"0.59654796",
"0.5924792",
"0.5886461",
"0.587063",
"0.58324575",
"0.5809455",
"0.5807334",
"0.5799182",
"0.57891464",
"0.5780056",
"0.5752148",
"0.5748409",
"0.5745303... | 0.68255717 | 1 |
returns an array of cell volumes of structured grid created from fenics triangular grid | def structured_cell_volumes(mesh):
dim = mesh.topology().dim()
stride = fact(dim)
vols = get_cell_volumes(mesh)
num_cells = int(mesh.num_cells()/stride)
return np.ones(num_cells, dtype=float)*stride*vols[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_array_grid(self):\n print('Making array grid')\n grid_list = []\n or_list = [0, 0, 0]\n far_list = [0, 0, 0]\n\n for root, subdirs, files in os.walk(self.stem):\n for filename in files:\n if self.probe in filename and self.prot_name in filename a... | [
"0.6504157",
"0.64335394",
"0.6400999",
"0.6392453",
"0.63127804",
"0.6261576",
"0.62555546",
"0.62192905",
"0.6213598",
"0.61927265",
"0.61504424",
"0.6096406",
"0.6015397",
"0.5978754",
"0.5973437",
"0.59621096",
"0.59490955",
"0.5942069",
"0.59264094",
"0.58781314",
"0.587... | 0.61203617 | 11 |
generates a 3D box mesh with tetrahedral elements with a cylindrical hole in it input | def box_mesh(point1=Point(0,0,0), point2=Point(2,1,1),
numptsX=8, numptsY=4, numptsZ=4):
mesh = BoxMesh(point1, point2, numptsX, numptsY, numptsZ)
print_mesh_stats(mesh)
return mesh | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def box_mesh_with_hole(point1=Point(0,0,0), point2=Point(2,1,1), cyl_cent1 = Point(1, -10, 0.5), \n cyl_cent2= Point(1, 10, 0.5), cyl_rad=0.25, numpts=15):\n Router = mshr.Box(point1, point2)\n Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad)\n domain = Router - Rinner\n... | [
"0.6957441",
"0.63803893",
"0.62517613",
"0.62113863",
"0.6197783",
"0.6191623",
"0.6189739",
"0.6144739",
"0.6058943",
"0.6045965",
"0.60435003",
"0.59895325",
"0.5982015",
"0.592962",
"0.59281814",
"0.59142035",
"0.5913737",
"0.5881925",
"0.5879472",
"0.5861976",
"0.5861803... | 0.6045953 | 10 |
generates a 3D box mesh with tetrahedral elements with a cylindrical hole in it input | def box_mesh_with_hole(point1=Point(0,0,0), point2=Point(2,1,1), cyl_cent1 = Point(1, -10, 0.5),
cyl_cent2= Point(1, 10, 0.5), cyl_rad=0.25, numpts=15):
Router = mshr.Box(point1, point2)
Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad)
domain = Router - Rinner
mesh = mshr.generate_mesh(domain, numpts)
print_mesh_stats(mesh)
return mesh | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_lattice(box):\n from quippy.atoms import make_lattice\n if box.shape == (3, 3):\n\t# http://lammps.sandia.gov/doc/Section_howto.html#howto-12 Describes the\n\t# methodology (look for the section entitled \"6.12. Triclinic\n\t# (non-orthogonal) simulation boxes\") The [a, b, c, alpha, beta, gamma]\n\... | [
"0.63809776",
"0.62516385",
"0.6212014",
"0.61972636",
"0.6192103",
"0.6190166",
"0.6146428",
"0.60585725",
"0.604773",
"0.6045741",
"0.6044307",
"0.5990217",
"0.59825504",
"0.59320945",
"0.59280205",
"0.5914633",
"0.59137803",
"0.5881047",
"0.5878436",
"0.58624035",
"0.58605... | 0.6957271 | 0 |
returns the cell centroids lying within given geometric extents | def get_cell_centroid2(cents, extents):
cells_in_ee = np.empty(0,int)
for i in range(len(cents)):
c = cents[i]
if( (c > extents[0]).all() and (c <= extents[1]).all() ):
cells_in_ee = np.append(cells_in_ee, [i], axis=0)
return cells_in_ee | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_centroid_cell(self):\n\n x_min, y_min = self.find_min()\n x_max, y_max = self.find_max()\n x_centroid = int((x_max+x_min)/2)\n y_centroid = int((y_max+y_min)/2)\n centroide = x_centroid, y_centroid\n return centroide",
"def cells_centroid_py(self):\n A=se... | [
"0.6934343",
"0.688382",
"0.672464",
"0.66895455",
"0.6638991",
"0.65940636",
"0.65940636",
"0.6519114",
"0.6447519",
"0.63558304",
"0.6343967",
"0.62743145",
"0.6219808",
"0.6177495",
"0.6171115",
"0.6169734",
"0.6126709",
"0.6084704",
"0.60784847",
"0.60754013",
"0.6071603"... | 0.79571277 | 0 |
given a fenics mesh/mshr.mesh as argument, returns the centroid of the cells in the mesh input | def get_cell_centroids(mesh):
num_els = mesh.num_cells()
coords = mesh.coordinates()
cells = mesh.cells()
dim = len(coords[0])
cell_cent = np.zeros((num_els, dim), dtype=float, order='c')
for i in range(num_els):
pts = [coords[idx] for idx in cells[i]]
cell_cent[i] = (1/(dim+1))*sum(pts) #this works only for 2D/3D triangles
return cell_cent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def structured_cell_centroids(mesh):\n dim = mesh.topology().dim()\n stride = fact(dim)\n cents = get_cell_centroids(mesh)\n num_cells = int(mesh.num_cells()/stride)\n cell_cents_struct = np.zeros((num_cells,dim),dtype=float)\n\n for i in range(num_cells):\n start = int(stride*i)\n ... | [
"0.7213677",
"0.68678993",
"0.68678993",
"0.68211424",
"0.67176604",
"0.6685038",
"0.6652162",
"0.6585276",
"0.65823853",
"0.6560574",
"0.65416116",
"0.65348834",
"0.64790154",
"0.64459264",
"0.6443465",
"0.6432527",
"0.64168453",
"0.63676035",
"0.63556105",
"0.6349497",
"0.6... | 0.7951323 | 0 |
given a fenics/mshr mesh as argument, this function returns the area of each cell in the mesh input | def get_cell_volumes(mesh):
num_els = mesh.num_cells()
coords = mesh.coordinates()
cells = mesh.cells()
dim = len(coords[0])
cell_volume = np.zeros(num_els, dtype=float)
div_fact = 1.0/float(fact(dim)) #division factor for n-dim tetrahderon
for i in range(num_els):
cell_volume[i] = abs(la.det(np.insert(coords[cells[i]], dim, 1, axis=1)))
return div_fact*cell_volume | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_mesh_area(mesh):\n vertices = mesh.vertices\n faces = mesh.faces\n areas = [compute_triangle_area(vertices[face]) for face in faces]\n mesh_surface_area = sum(areas)\n return mesh_surface_area",
"def compute_mesh_area_numpy(mesh):\n pass",
"def compute_mesh_area_smart(mesh):\n ... | [
"0.7731537",
"0.7606668",
"0.7485298",
"0.67880005",
"0.6668737",
"0.6619852",
"0.65239465",
"0.65232146",
"0.6518488",
"0.6516006",
"0.6474902",
"0.6462257",
"0.6318234",
"0.63121057",
"0.62883294",
"0.62868917",
"0.6269633",
"0.62583816",
"0.6257095",
"0.6177899",
"0.617129... | 0.569701 | 56 |
given a fenics mesh, this function returns the bounding_box that fits around the domain | def get_domain_bounding_box(mesh=None, cell_cent=None):
def local_bbox_method(coords):
dim = len(coords[0])
corner_min = np.zeros(dim ,float)
corner_max = np.zeros(dim, float)
for d in range(dim):
corner_min[d] = min(coords[:,d])
corner_max[d] = max(coords[:,d])
return np.vstack((corner_min, corner_max))
if mesh==None and len(np.shape(cell_cent)) == 0:
raise AssertionError("provide either fenics mesh or cell centroid of PD particles")
if mesh != None and len(np.shape(cell_cent)) == 0:
coords = mesh.coordinates()
return local_bbox_method(coords)
if cell_cent.all() and not mesh:
coords = cell_cent
return local_bbox_method(coords) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bounds(self):\n return self._bboxes[0][0] #TODO: merge all coverages",
"def get_bounding_box(self):\n return self._domain.get_bounding_box()",
"def get_boundingbox(face, width, height, scale=1.3, minsize=None):\n x1 = face.left()\n y1 = face.top()\n x2 = face.right()\n y2 = face.bottom... | [
"0.68726236",
"0.6643377",
"0.66258126",
"0.6624291",
"0.66229665",
"0.6602934",
"0.659407",
"0.6578977",
"0.6496308",
"0.6475542",
"0.63955826",
"0.6387074",
"0.6363856",
"0.63531804",
"0.63405913",
"0.6319945",
"0.6304606",
"0.62939525",
"0.6264529",
"0.62618446",
"0.625956... | 0.7623161 | 0 |
returns lists of elements and centroids of corresponding elements that lie in the peridynamic boundary | def get_peridym_mesh_bounds(mesh, struct_grd=False):
if(struct_grd):
cell_cent = structured_cell_centroids(mesh)
max_edge_len = np.diff(cell_cent[0:2][:,0])
range_fact = 2.001*max_edge_len
else:
cell_cent = get_cell_centroids(mesh)
max_edge_len = mesh.hmax()
range_fact = 1.5001*max_edge_len
dim = len(cell_cent[0])
corner_min, corner_max = get_domain_bounding_box(mesh)
num_els = len(cell_cent)
bound_range = np.zeros(2*dim, dtype=float)
bound_nodes = {} #dict to store the node numbers of centroids that lie within bound_range
bound_cents = {} #dict to store the node centroids corresponding to node numbers above
for d in range(dim):
"""
index to direction along which the normal to boundary occurs:#
0 - x_min
1 - x_max
2 - y_min
3 : y_max
4 : z_min
5 : z_max
Note: z-normal not applicable to 2d problems
"""
bound_range[2*d] = corner_min[d] + range_fact #min bound for d
bound_range[2*d +1] = corner_max[d] - range_fact #max bound for d
bound_nodes[(2*d)] = np.where(cell_cent[:,d] <= bound_range[2*d]) #node nums for min bound
bound_nodes[(2*d+1)] = np.where(cell_cent[:,d] >= bound_range[2*d+1]) # node nums for max bound
bound_cents[(2*d)] = cell_cent[bound_nodes[2*d][0]] #node centroids for min bound
bound_cents[(2*d+1)] = cell_cent[bound_nodes[2*d+1][0]] #node centroids for min bound
return bound_nodes, bound_cents #convert list to np array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_element_centroids(self):\n if self.centroids is None:\n self.centroids = np.vstack((\n np.mean(self.grid['x'], axis=1),\n np.mean(self.grid['z'], axis=1)\n )).T\n\n return self.centroids",
"def compute_barycenters(self):\n barycente... | [
"0.70245355",
"0.7002935",
"0.6660773",
"0.62237847",
"0.6222728",
"0.6192791",
"0.61816937",
"0.6137272",
"0.6075676",
"0.599824",
"0.5997937",
"0.59680784",
"0.59588766",
"0.5945071",
"0.592016",
"0.58423734",
"0.5838941",
"0.5807597",
"0.5790801",
"0.5777944",
"0.576687",
... | 0.5779456 | 19 |
given a set of cell centroid beloning to regular (Square/Tri) discretization in 2D/3D, the method returns the edge length | def get_peridym_edge_length(cell_cent, struct_grd=False):
dim = len(cell_cent[0])
el = np.zeros(dim, dtype = float)
if(struct_grd):
el_fact = 1.0
else:
el_fact = 3.0
for d in range(dim):
xx = np.unique(cell_cent[:,d])
el[d] = el_fact*np.max(np.abs(np.diff(xx[0:2])))
return el | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cell_centroids_original(crd, con):\n \n nele = con.shape[0]\n dim = crd.shape[1]\n centroid_xy = np.zeros((nele, dim))\n for i in range(len(con)):\n el_crds = crd[con[i, :], :] # (4, 2)\n centroid_xy[i, :] = (el_crds).mean(axis=0)\n return centroid_xy",
"def cell_edges(self):",
... | [
"0.6159054",
"0.610381",
"0.6095435",
"0.6027462",
"0.6002276",
"0.59965074",
"0.5987988",
"0.58697575",
"0.58489704",
"0.5763668",
"0.574332",
"0.5738635",
"0.57146585",
"0.5661359",
"0.5644903",
"0.56421226",
"0.5631822",
"0.5622291",
"0.55991775",
"0.55730665",
"0.5567386"... | 0.6498209 | 0 |
after adding ghost layers, the boundary layers are modified and we need the modified BL's to do further pre and postprocessing | def get_modified_boundary_layers(cell_cent, el, num_lyrs, struct_grd):
dim = len(el)
bound_range = np.zeros(2*dim, dtype=float)
bound_nodes = {} #dict to store the node numbers of centroids that lie within bound_range
bound_cents = {} #dict to store the node centroids corresponding to node numbers above
if(struct_grd):
factor = 1
correction = 0
else:
factor = 2
correction = 1
lyrs = float(num_lyrs-1)+ 0.001
for d in range(dim):
bound_range[2*d] = factor*np.min(cell_cent[:,d]) + lyrs*el[d]
bound_range[2*d+1] = np.max(cell_cent[:,d]) -lyrs*el[d] - el[d]/3*correction
bound_nodes[2*d] = np.where(cell_cent[:,d] <= bound_range[2*d])
bound_nodes[(2*d+1)] = np.where(cell_cent[:,d] >= bound_range[2*d+1])
bound_cents[2*d] = cell_cent[bound_nodes[2*d][0]]
bound_cents[2*d+1] = cell_cent[bound_nodes[2*d+1][0]]
return bound_nodes, bound_cents | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_layers(self):\n cls_branch = []\n for _ in range(self.num_reg_fcs):\n cls_branch.append(Linear(self.embed_dims, self.embed_dims))\n cls_branch.append(nn.LayerNorm(self.embed_dims))\n cls_branch.append(nn.ReLU(inplace=True))\n cls_branch.append(Linear(... | [
"0.61987007",
"0.60086524",
"0.5981845",
"0.5945961",
"0.5919441",
"0.5910352",
"0.5873379",
"0.58416927",
"0.584018",
"0.58067274",
"0.5799793",
"0.57604694",
"0.57457453",
"0.57456446",
"0.5722169",
"0.56993973",
"0.56873125",
"0.5686807",
"0.5664177",
"0.56639755",
"0.5658... | 0.0 | -1 |
computes the extents of the new mesh after the addition of ghost layers of centroids | def compute_modified_extents(cell_cent, el, struct_grd=False):
dim = len(cell_cent[0])
extents = np.zeros((2, dim), float)
min_corners = np.zeros(dim, float)
max_corners = np.zeros(dim, float)
if(struct_grd):
shift_fact = 0.5
else:
shift_fact = 1.0/3.0
for d in range(dim):
min_corners[d] = np.min(cell_cent[:,d])
max_corners[d] = np.max(cell_cent[:,d])
"""
below is done to avoid round-off error due to
substraction of two numbers near to each other
This occurs when corners in one of the dimension
remains unchanged but we still try to compute
the new extents
"""
extents[0][d] = round(min_corners[d] - shift_fact*el[d], 16)
extents[1][d] = round(max_corners[d] + shift_fact*el[d], 16)
return extents | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cfdProcessGeometry(self):\r\n \r\n # self.faceCentroids']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceSf']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceAreas']= [[] for i in range(self.numberOfFaces'])]\r\n \r\n ## Linear weight of distance from cel... | [
"0.6003565",
"0.58814555",
"0.58328587",
"0.56252813",
"0.54995984",
"0.5355394",
"0.5334341",
"0.52900535",
"0.5283956",
"0.5225239",
"0.5213403",
"0.52073336",
"0.52039486",
"0.52000946",
"0.5199819",
"0.5195994",
"0.5187157",
"0.5172253",
"0.5169794",
"0.5148453",
"0.51294... | 0.56990963 | 3 |
writes the peridynamic mesh coordinates to a vetk supported file format | def write_to_vtk(mesh, displacement=None, file_name="gridfile"):
cents = get_cell_centroids(mesh)
dim = len(cents[0])
if displacement is not None:
cents+= displacement
file_name = "./"+file_name
write_function=None
if dim==3:
write_function = write_to_vtk3D
if dim==2:
write_function = write_to_vtk2D
write_function(cents, displacement, file_name)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeMeshVTP(self, outFile):\n # setup colors\n Colors = vtk.vtkFloatArray()\n #Colors.SetNumberOfComponents(3)\n Colors.SetNumberOfTuples(self.Npts)\n Colors.SetName(self.label) #can change to any string\n\n #points\n vtkPts = vtk.vtkPoints()\n\n #build ... | [
"0.7374671",
"0.7342227",
"0.72970176",
"0.7035716",
"0.6870228",
"0.6849702",
"0.67708486",
"0.66564435",
"0.6611505",
"0.6559381",
"0.6552022",
"0.65475076",
"0.645451",
"0.64042014",
"0.6353414",
"0.6322365",
"0.6314053",
"0.62772197",
"0.626675",
"0.6251661",
"0.6200027",... | 0.6905679 | 4 |
writes 3D data to vtk file | def write_to_vtk3D(cents, displacement, file_name):
x,y,z = cents.T
x = np.array(x, order='c')
y = np.array(y, order='c')
z = np.array(z, order='c')
if displacement is None:
pointsToVTK(file_name, x, y, z, data={"x":x, "y":y, "z":z})
else:
dispX, dispY, dispZ = displacement.T
dispX = np.array(dispX, order='c')
dispY = np.array(dispY, order='c')
dispZ = np.array(dispZ, order='c')
pointsToVTK(file_name, x, y, z, data={"x":x, "y":y, "z":z,
"dispX":dispX, "dispY":dispY, "dispZ":dispZ})
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_to_vtk(mesh, displacement=None, file_name=\"gridfile\"):\n cents = get_cell_centroids(mesh)\n dim = len(cents[0])\n \n if displacement is not None:\n cents+= displacement\n \n file_name = \"./\"+file_name\n \n write_function=None\n if dim==3:\n write_function = w... | [
"0.72473127",
"0.7167763",
"0.712707",
"0.70639265",
"0.70125705",
"0.6693387",
"0.66590923",
"0.6534829",
"0.6533069",
"0.6519555",
"0.6518537",
"0.6369265",
"0.6330161",
"0.62977713",
"0.62542105",
"0.6210785",
"0.61916816",
"0.61361706",
"0.6113361",
"0.61057776",
"0.60783... | 0.66667515 | 6 |
writes 2D data to VTK | def write_to_vtk2D(cents, displacement, file_name):
x,y = cents.T
x = np.copy(x, order='c')
y = np.copy(y, order='c')
z = np.zeros(len(x), order='c')
if displacement is None:
pointsToVTK(file_name, x, y, z, data={"x":x, "y":y})
else:
dispX, dispY = displacement.T
dispX = np.array(dispX, order='c')
dispY = np.array(dispY, order='c')
pointsToVTK(file_name, x, y, z, data={"x":x, "y":y,
"dispX":dispX, "dispY":dispY})
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveVelocityAndPressureVTK_binary(pressure,u,v,w,x,y,z,filename,dims):\n numEl_size = u.size; numEl = np.prod(numEl_size);\n # open the file and write the ASCII header:\n file = open(filename,'w')\n file.write('# vtk DataFile Version 3.0\\n')\n file.write('VTK file for data post-processed with P... | [
"0.70123774",
"0.68971926",
"0.6655694",
"0.6629076",
"0.64621574",
"0.6329957",
"0.6204803",
"0.6192847",
"0.60517424",
"0.599518",
"0.59665126",
"0.5899244",
"0.58768153",
"0.5847911",
"0.5827327",
"0.5739005",
"0.57155335",
"0.57155335",
"0.57111055",
"0.5698415",
"0.56801... | 0.62436384 | 6 |
creates n distint colors for plts, where n = num_colors | def get_colors(num_colors):
import colorsys
colors = []
for i in np.arange(0., 360., 360. / num_colors):
hue = i/360.
lightness = (50 + np.random.rand() * 10)/100.
saturation = (90 + np.random.rand() * 10)/100.
colors.append(colorsys.hls_to_rgb(hue, lightness, saturation))
return colors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_funky_cmap(n_colors):\n\n colors = []\n for i in np.arange(0., 360., 360. / n_colors):\n h = i / 360.\n l = (50 + np.random.rand() * 10) / 100.\n s = (90 + np.random.rand() * 10) / 100.\n colors.append(hls_to_rgb(h, l, s))\n\n return colors",
"def generate_n_colors... | [
"0.749464",
"0.74524117",
"0.7178915",
"0.71482074",
"0.7119622",
"0.7088267",
"0.6929152",
"0.6905464",
"0.68315506",
"0.6754532",
"0.672276",
"0.6686234",
"0.6637927",
"0.66152275",
"0.6572149",
"0.6569774",
"0.6569445",
"0.65186614",
"0.650056",
"0.6491387",
"0.6475267",
... | 0.66890764 | 11 |
returns list of markers to be used for plt functions; max markers allowed = 18 | def get_markers(num_markers):
markers = ['^','o','P','X','*', 'd','<', '>', ',','|', '1','2','3','4','s','p','*','h','+']
if(num_markers>18):
sys.exit("cannot create more than 18 markers, refactor your code; force exiting")
return markers[0:num_markers] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_markerstyles(n=None):\n all_markers = ['o', 'D', 's', '2', '*', 'h', '8', 'v', 'x', '+', 5, 'd', '>', 7, '.', '1', 'p', '3',\n 6, 0, 1, 2, 3, 4, '4', '<', 'H', '^']\n # Note: 0: 'tickleft', 1: 'tickright', 2: 'tickup', 3: 'tickdown', 4: 'caretleft', 'D': 'diamond', 6: 'caretup',\n ... | [
"0.65396273",
"0.6017809",
"0.5980015",
"0.5968961",
"0.5907878",
"0.5887821",
"0.5838874",
"0.5838874",
"0.5829966",
"0.58082724",
"0.5748896",
"0.5732162",
"0.5673139",
"0.5570676",
"0.5556668",
"0.5437964",
"0.5424193",
"0.5405786",
"0.53380895",
"0.53265303",
"0.5313803",... | 0.74688494 | 0 |
Basic attach/detach IPv6 test with single UE | def test_attach_detach_ipv6(self):
num_ues = 2
detach_type = [
s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value,
s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value,
]
wait_for_s1 = [True, False]
self._s1ap_wrapper.configUEDevice(num_ues)
# Default apn over-write
magma_default_apn = {
"apn_name": "magma.ipv4", # APN-name
"qci": 9, # qci
"priority": 15, # priority
"pre_cap": 1, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
"pdn_type": 2, # PDN Type 0-IPv4,1-IPv6,2-IPv4v6
}
apn_list = [magma_default_apn]
for i in range(num_ues):
req = self._s1ap_wrapper.ue_req
print(
"************************* Running End to End attach for ",
"UE id ", req.ue_id,
)
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(j) for j in req.imsi]),
apn_list, default=False,
)
# Now actually complete the attach
self._s1ap_wrapper._s1_util.attach(
req.ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
pdn_type=2,
)
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
print(
"************************* Running UE detach for UE id ",
req.ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
req.ue_id, detach_type[i], wait_for_s1[i],
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mgre6(self):\n\n self.pg0.config_ip6()\n self.pg0.resolve_ndp()\n\n e = VppEnum.vl_api_tunnel_encap_decap_flags_t\n\n for itf in self.pg_interfaces[3:]:\n #\n # one underlay nh for each overlay/tunnel peer\n #\n itf.config_ip6()\n ... | [
"0.6983675",
"0.6860099",
"0.6674686",
"0.6540398",
"0.6405422",
"0.63681173",
"0.6198082",
"0.61734575",
"0.6095474",
"0.6050625",
"0.602617",
"0.6024223",
"0.59982115",
"0.59627396",
"0.59101856",
"0.58795923",
"0.5868089",
"0.58631897",
"0.5853766",
"0.5821142",
"0.5754354... | 0.83120114 | 0 |
Create a Pandas DataFrame out of a .yaml file. Examples | def yaml_to_pandas(filename: str) -> Tuple[pd.DataFrame, Optional[str]]:
# Read the yaml file
with open(filename, 'r') as f:
dict_ = yaml.load(f, Loader=yaml.SafeLoader)
project = dict_.pop("__project__", None)
# Convert the yaml dictionary into a dataframe
data: Dict[str, Dict[Tuple[Hashable, Hashable], Any]] = {}
for k1, v1 in dict_.items():
for k2, v2 in v1['users'].items():
data[k2] = {('info', k): v for k, v in v1.items() if k != 'users'}
data[k2][NAME] = v2
data[k2][PROJECT] = k1
df = pd.DataFrame(data).T
# Fortmat, sort and return the dataframe
df.index.name = 'username'
df[SBU_REQUESTED] = df[SBU_REQUESTED].astype(float)
df[TMP] = df.index
df.sort_values(by=[PROJECT, TMP], inplace=True)
df.sort_index(axis=1, inplace=True, ascending=False)
del df[TMP]
df[ACTIVE] = False
validate_usernames(df)
return df, project | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_to_dataframe(\n filename: Union[Path, str],\n marker: str = \"---\",\n csv_options: Optional[Dict[str, Any]] = None,\n yaml_options: Optional[Dict[str, Any]] = None,\n) -> Tuple[DataFrame, Dict[str, Any]]:\n if DataFrame is None:\n raise ModuleNotFoundError(\n \"Module pan... | [
"0.6223266",
"0.6129303",
"0.6100554",
"0.60840815",
"0.6082889",
"0.5902778",
"0.5898788",
"0.5859711",
"0.5854862",
"0.5829673",
"0.5819154",
"0.58064884",
"0.58064884",
"0.5772481",
"0.5768575",
"0.57589835",
"0.5717933",
"0.5713953",
"0.5706922",
"0.5706922",
"0.5701406",... | 0.6970648 | 0 |
Validate that all users belonging to an account are available in the .yaml input file. Raises a KeyError If one or more usernames printed by the ``accinfo`` comand are absent from df. | def validate_usernames(df: pd.DataFrame) -> None:
_usage = check_output(['accinfo'], encoding='utf8')
iterator = filter(None, _usage.splitlines())
for i in iterator:
if i == "# Users linked to this account":
usage = np.array(list(iterator), dtype=np.str_)
break
else:
raise ValueError("Failed to parse the passed .yaml file")
bool_ar1 = np.isin(usage, df.index)
bool_ar2 = np.isin(df.index, usage)
name_diff = ""
name_diff += "".join(f"\n- {name}" for name in usage[~bool_ar1])
name_diff += "".join(f"\n+ {name}" for name in df.index[~bool_ar2].values)
if name_diff:
raise ValueError(f"User mismatch between .yaml file and `accinfo` output:{name_diff}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_user_data(user_data):\n return 'account_ids' in user_data and 'monthly_expenses' in user_data",
"def load_users():\n try:\n # json file should be in the same file location as the function\n base_dir = os.path.dirname(__file__)\n abs_file = os.path.join(base_dir, 'users.json')... | [
"0.5713202",
"0.5615229",
"0.56124175",
"0.556478",
"0.5467763",
"0.5272703",
"0.5202546",
"0.52003455",
"0.5149381",
"0.5146254",
"0.51337475",
"0.5124031",
"0.509678",
"0.5084452",
"0.5061947",
"0.5024947",
"0.5024677",
"0.49984267",
"0.49967858",
"0.4986641",
"0.49853197",... | 0.76862663 | 0 |
This is our handler for the menu item. Our inItemRef is the refcon we registered in our XPLMAppendMenuItem calls. It is either +1000 or 1000 depending on which menu item is picked. | def MyMenuHandlerCallback(self, inMenuRef, inItemRef):
if (self.DataRef != 0):
"""
We read the data ref, add the increment and set it again.
This changes the nav frequency.
"""
XPLMSetDatai(self.DataRef, XPLMGetDatai(self.DataRef) + inItemRef)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_menu ( self, menu_item ):\r\n pass",
"def on_menu_item(self, e):\n if e.Id == ids.RESTORE:\n wx.PostEvent(self.app.roster, ev.ShowRoster())\n elif e.Id == ids.HIDE:\n wx.PostEvent(self.app.roster, ev.HideRoster())\n elif e.Id == ids.EXIT:\n ... | [
"0.61091536",
"0.57265496",
"0.55302376",
"0.5491266",
"0.5436538",
"0.5421155",
"0.54151934",
"0.54015744",
"0.53766143",
"0.5230789",
"0.5225447",
"0.522308",
"0.5221148",
"0.5216817",
"0.5182499",
"0.5182356",
"0.51636726",
"0.5154699",
"0.51006156",
"0.5060227",
"0.505950... | 0.7293928 | 0 |
Add constant to elf and return corresponding index If constant already existed, this method won't make a new copy | def add_constant(self, type_: str, value):
assert type_ in [Constant.STR, Constant.INT,
Constant.DOUBLE], 'Error constant type'
for idx, const in enumerate(self.constants):
if (const.type_, const.value) == (type_, value):
return idx
self.constants.append(Constant(type_, value))
return len(self.constants) - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_const(self, constant):\n for i in range(len(self.consts)):\n if type(self.consts[i]) == type(constant) and self.consts[i] == constant:\n return i\n\n self.consts.append(constant)\n return len(self.consts) - 1",
"def add_constant(value, name):\n\n # TODO: inefficient linear search... | [
"0.6549235",
"0.5801646",
"0.564684",
"0.5430631",
"0.54223347",
"0.52493185",
"0.517787",
"0.5129371",
"0.50737894",
"0.5043636",
"0.50140244",
"0.49892992",
"0.4976119",
"0.49711967",
"0.4970512",
"0.49640742",
"0.4963301",
"0.49513727",
"0.49467608",
"0.49171853",
"0.49073... | 0.57320184 | 2 |
Returns a string representation of a template action. | def tmpl_to_str(self, template_idx, o1_id, o2_id):
template_str = self.template_generator.templates[template_idx]
holes = template_str.count('OBJ')
assert holes <= 2
if holes <= 0:
return template_str
elif holes == 1:
return template_str.replace('OBJ', self.vocab_act[o1_id])
else:
return template_str.replace('OBJ', self.vocab_act[o1_id], 1)\
.replace('OBJ', self.vocab_act[o2_id], 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def action_to_str(action):\n raise NotImplementedError",
"def action_to_pretty_str(action) :\n raise NotImplementedError",
"def actionString(self,action):\n return str(self._mdp.A[action])",
"def __str__(self):\n return _action_args_dict[self.action].name",
"def as_action(self) ... | [
"0.7366068",
"0.73624396",
"0.7298899",
"0.7282407",
"0.72067684",
"0.7068115",
"0.6933396",
"0.6931171",
"0.6851052",
"0.68281645",
"0.6725535",
"0.6540052",
"0.6448798",
"0.6448798",
"0.6302694",
"0.62781346",
"0.62517726",
"0.62420046",
"0.62164974",
"0.62151736",
"0.61607... | 0.5388328 | 68 |
Returns the computational basis samples generated for all wires. In the _qubit_device.py, the function calls for analytic_probability for its operations. | def generate_samples(self):
self.analytic_probability() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_all_samples(self):\n\n n_samples, n_dimensions, V = self.n_samples, self.n_dimensions, self.V\n sample_all = np.zeros([n_samples, n_dimensions])\n\n X = int(0)\n for j in range(1, n_samples):\n X ^= V[self.index_of_least_significant_zero_bit(j - 1)]\n ... | [
"0.6354442",
"0.6312051",
"0.6045636",
"0.5982405",
"0.5920717",
"0.58340013",
"0.57912403",
"0.5770052",
"0.5703894",
"0.5652854",
"0.5625554",
"0.5597974",
"0.5590781",
"0.5573974",
"0.5573084",
"0.5562036",
"0.55604845",
"0.55475634",
"0.55385345",
"0.552718",
"0.552718",
... | 0.5722098 | 8 |
Statistics of operation calls | def operation_calls(self):
return self._operation_calls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def callstats(): # real signature unknown; restored from __doc__\n return ()",
"def compute_statistics(self):",
"def op_callcount(self):\r\n # timing is stored by node, we compute timing by Op on demand\r\n rval = {}\r\n for node, count in self.apply_callcount.items():\r\n rv... | [
"0.7313468",
"0.7228227",
"0.7212459",
"0.7169933",
"0.6866486",
"0.6595815",
"0.6593144",
"0.6504629",
"0.64714056",
"0.6452719",
"0.6406453",
"0.6396562",
"0.6314827",
"0.6296872",
"0.62631065",
"0.6217563",
"0.6191796",
"0.61761403",
"0.6125694",
"0.61125034",
"0.6077134",... | 0.6650646 | 5 |
load data Divide the train set into train set and crossvalidation set in ratio. | def load_data(trainfile, testfile):
raw_train = pd.read_csv(trainfile, header=None)
raw_test = pd.read_csv(testfile, header=None)
train = raw_train.values
test = raw_test.values
train_features = train[0::, 1::]
train_label = train[::, 0]
test_features = test[0::, 1::]
test_label = test[::, 0]
train, cv , train_label, cv_label = train_test_split(train_features,train_label, test_size=0.33, random_state=42)
return train, train_label, \
cv, cv_label, \
test_features, test_label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_test_loaders(dataset, validation_ratio=0.2, **kwargs):\n dataset_size = len(dataset)\n test_size = int(np.floor(validation_ratio * dataset_size))\n train_size = dataset_size - test_size\n print('TRAIN SIZE {}'.format(train_size))\n print('TEST SIZE {}'.format(test_size))\n train_dataset... | [
"0.7038124",
"0.68708676",
"0.6773931",
"0.66979957",
"0.6655997",
"0.66537637",
"0.6629245",
"0.6622395",
"0.6614368",
"0.6608594",
"0.6596205",
"0.65692824",
"0.6518721",
"0.6510277",
"0.6498947",
"0.6481965",
"0.64735436",
"0.64697593",
"0.64670414",
"0.64647627",
"0.64571... | 0.67273855 | 3 |
gR(D,A) = (H(D) H(D|A)) / H(D|A) | def _cal_igr(x, y):
return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def g(self, RD):\n g = 1 / np.sqrt((1 + 3 * np.power(self.q, 2)) / np.power(np.pi, 2)) \n \n return g",
"def g(r):\n return np.cos(r) / (np.exp(0.4 * (r - 8)) + 1)",
"def r0(self):\n return self.p[0] / self.p[1]",
"def get_rm(g):\n return 1 / g",
"def calculate_gear_ra... | [
"0.65369403",
"0.6507665",
"0.6253428",
"0.6249482",
"0.6246978",
"0.6144162",
"0.6086388",
"0.608423",
"0.6083159",
"0.60784787",
"0.60262895",
"0.5952174",
"0.5915985",
"0.5905272",
"0.5902779",
"0.5874937",
"0.5870388",
"0.58570063",
"0.5824216",
"0.582396",
"0.58188695",
... | 0.5556284 | 42 |
Build Data Docs for a project. | def docs_build(directory, site_name, view=True, assume_yes=False):
context = toolkit.load_data_context_with_error_handling(directory)
build_docs(context, site_name=site_name, view=view, assume_yes=assume_yes)
toolkit.send_usage_message(
data_context=context, event="cli.docs.build", success=True
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_documentation(self):\n self.generate_api_docs()\n build.main([\n self.SOURCE_DIR,\n self.BUILD_DIR,\n ])",
"def build_docs(context, site_name=None, view=True, assume_yes=False):\n logger.debug(\"Starting cli.datasource.build_docs\")\n\n if site_name i... | [
"0.6422397",
"0.64200485",
"0.63599217",
"0.63230777",
"0.6303222",
"0.6295382",
"0.61533386",
"0.6144586",
"0.60924774",
"0.60924774",
"0.60924774",
"0.60327756",
"0.6032378",
"0.5982227",
"0.59735847",
"0.59703684",
"0.59529877",
"0.59529877",
"0.5898977",
"0.58841336",
"0.... | 0.58279645 | 24 |
List known Data Docs Sites. | def docs_list(directory):
context = toolkit.load_data_context_with_error_handling(directory)
docs_sites_url_dicts = context.get_docs_sites_urls()
docs_sites_strings = [
" - <cyan>{}</cyan>: {}".format(
docs_site_dict["site_name"],
docs_site_dict.get("site_url")
or f"site configured but does not exist. Run the following command to build site: great_expectations "
f'docs build --site-name {docs_site_dict["site_name"]}',
)
for docs_site_dict in docs_sites_url_dicts
]
if len(docs_sites_strings) == 0:
cli_message("No Data Docs sites found")
else:
list_intro_string = _build_intro_string(docs_sites_strings)
cli_message_list(docs_sites_strings, list_intro_string)
toolkit.send_usage_message(
data_context=context, event="cli.docs.list", success=True
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_all(client):\n return list(map(lambda s: Site(s), client.get_api_resource(\"self/sites\")))",
"def list_sites():\n sites = db_client.query_sites_list()\n return jsonify(sites)",
"def list_sites():\n result = []\n querystring = 'select sitename from {};'.format(TABLES[0]))\n res =... | [
"0.68871546",
"0.6885869",
"0.66649675",
"0.6592278",
"0.6572376",
"0.6511911",
"0.65085405",
"0.6494182",
"0.6483239",
"0.64800274",
"0.6446842",
"0.64075714",
"0.63722503",
"0.63695705",
"0.63695705",
"0.62545717",
"0.6170089",
"0.61219245",
"0.60714644",
"0.6027309",
"0.59... | 0.6646616 | 3 |
Build documentation in a context | def build_docs(context, site_name=None, view=True, assume_yes=False):
logger.debug("Starting cli.datasource.build_docs")
if site_name is not None:
site_names = [site_name]
else:
site_names = None
index_page_locator_infos = context.build_data_docs(
site_names=site_names, dry_run=True
)
msg = "\nThe following Data Docs sites will be built:\n\n"
for site_name, index_page_locator_info in index_page_locator_infos.items():
msg += " - <cyan>{}:</cyan> ".format(site_name)
msg += "{}\n".format(index_page_locator_info)
cli_message(msg)
if not assume_yes:
toolkit.confirm_proceed_or_exit()
cli_message("\nBuilding Data Docs...\n")
context.build_data_docs(site_names=site_names)
cli_message("Done building Data Docs")
if view:
context.open_data_docs(site_name=site_name, only_if_exists=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sphinxify(docstring, context, buildername='html'):\n\n srcdir = mkdtemp()\n srcdir = encoding.to_unicode_from_fs(srcdir)\n\n base_name = osp.join(srcdir, 'docstring')\n rst_name = base_name + '.rst'\n\n if buildername == 'html':\n suffix = '.html'\n else:\n suffix = '.txt'\n ... | [
"0.7200595",
"0.71286154",
"0.70953643",
"0.69826937",
"0.67844534",
"0.6753231",
"0.6731056",
"0.67097837",
"0.6688072",
"0.6656818",
"0.65566325",
"0.65320677",
"0.6452669",
"0.6432759",
"0.6430928",
"0.6357106",
"0.63557726",
"0.631642",
"0.63006896",
"0.62424266",
"0.6237... | 0.5954264 | 42 |
Normalize the batch data, use coordinates of the block centered at origin, | def normalize_data(batch_data):
B, N, C = batch_data.shape
normal_data = np.zeros((B, N, C))
for b in range(B):
pc = batch_data[b]
centroid = np.mean(pc, axis=0)
pc = pc - centroid
m = np.max(np.sqrt(np.sum(pc ** 2, axis=1)))
pc = pc / m
normal_data[b] = pc
return normal_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _normalize(self, dataset):\n if self.max is None: # if we are normalizing the training set\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\n for row in dataset.index: # for each row in dataset\n for c... | [
"0.69384634",
"0.68707067",
"0.6639805",
"0.6637574",
"0.65870476",
"0.647955",
"0.644119",
"0.63818425",
"0.6363857",
"0.626459",
"0.62471074",
"0.62398934",
"0.62313163",
"0.6193541",
"0.6191717",
"0.61898583",
"0.618904",
"0.61679614",
"0.6146879",
"0.61388755",
"0.6138875... | 0.7281029 | 0 |
Shuffle data and labels. | def shuffle_data(data, labels):
idx = np.arange(len(labels))
np.random.shuffle(idx)
return data[idx, ...], labels[idx], idx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shuffle_data(self):\n images = list(self.train_images)\n labels = list(self.train_labels)\n self.train_images = []\n self.train_labels = []\n\n # create list of permutated index and shuffle data accoding to list\n idx = np.random.permutation(len(labels))\n for i... | [
"0.84921646",
"0.84220874",
"0.800393",
"0.7868807",
"0.78123",
"0.7764462",
"0.7758387",
"0.76847744",
"0.7454648",
"0.74520284",
"0.7394949",
"0.7394949",
"0.73529667",
"0.72944164",
"0.7293919",
"0.7201344",
"0.7141838",
"0.70985335",
"0.7062494",
"0.70317477",
"0.69610476... | 0.77576107 | 9 |
Shuffle orders of points in each point cloud changes FPS behavior. Use the same shuffling idx for the entire batch. | def shuffle_points(batch_data):
idx = np.arange(batch_data.shape[1])
np.random.shuffle(idx)
return batch_data[:,idx,:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shuffle_points(batch_data):\n idx = np.arange(batch_data.shape[1])\n np.random.shuffle(idx)\n return batch_data[:, idx, :]",
"def shuffle_points(mutated_genome,index):\n random.shuffle(mutated_genome[index][2])",
"def _shuffle_roidb_idx(self):\n self.perm = np.random.permutation(np.arange... | [
"0.72801876",
"0.72373664",
"0.6753397",
"0.6724248",
"0.65495604",
"0.6484776",
"0.6474384",
"0.6474384",
"0.6457585",
"0.64205366",
"0.6403728",
"0.6389177",
"0.63853645",
"0.6350583",
"0.6297481",
"0.62960184",
"0.62893575",
"0.62821025",
"0.6237439",
"0.62186027",
"0.6217... | 0.725899 | 1 |
Randomly rotate the point clouds to augument the dataset rotation is per shape based along up direction | def rotate_point_cloud(batch_data):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
rotation_angle = np.random.uniform() * 2 * np.pi
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, 0, sinval],
[0, 1, 0],
[-sinval, 0, cosval]])
shape_pc = batch_data[k, ...]
rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix ... | [
"0.73846465",
"0.6965289",
"0.6953168",
"0.6815348",
"0.6815157",
"0.6815157",
"0.6747695",
"0.6692255",
"0.66423446",
"0.6594938",
"0.6594938",
"0.6594938",
"0.6522628",
"0.64682126",
"0.6416248",
"0.6369285",
"0.61995316",
"0.6168288",
"0.6102223",
"0.5960313",
"0.5927957",... | 0.6925797 | 5 |
Randomly rotate the point clouds to augument the dataset rotation is per shape based along up direction | def rotate_point_cloud_z(batch_data):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
rotation_angle = np.random.uniform() * 2 * np.pi
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, sinval, 0],
[-sinval, cosval, 0],
[0, 0, 1]])
shape_pc = batch_data[k, ...]
rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotate_point_cloud(data):\n rotated_data = np.zeros(data.shape, dtype=np.float32)\n for k in xrange(data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix ... | [
"0.7385551",
"0.69660366",
"0.69539493",
"0.69265366",
"0.69265366",
"0.69265366",
"0.6815256",
"0.67491716",
"0.6693226",
"0.66440564",
"0.65964067",
"0.65964067",
"0.65964067",
"0.65239024",
"0.6469736",
"0.64177275",
"0.63704824",
"0.6198356",
"0.61689585",
"0.6100769",
"0... | 0.6815286 | 7 |
Randomly perturb the point clouds by small rotations | def rotate_perturbation_point_cloud_with_normal(batch_data, angle_sigma=0.06, angle_clip=0.18):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)
Rx = np.array([[1,0,0],
[0,np.cos(angles[0]),-np.sin(angles[0])],
[0,np.sin(angles[0]),np.cos(angles[0])]])
Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],
[0,1,0],
[-np.sin(angles[1]),0,np.cos(angles[1])]])
Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],
[np.sin(angles[2]),np.cos(angles[2]),0],
[0,0,1]])
R = np.dot(Rz, np.dot(Ry,Rx))
shape_pc = batch_data[k,:,0:3]
shape_normal = batch_data[k,:,3:6]
rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), R)
rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1, 3)), R)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_lo... | [
"0.6232219",
"0.61596",
"0.6088852",
"0.6088638",
"0.60208404",
"0.59796554",
"0.5843116",
"0.5838049",
"0.5800207",
"0.5765245",
"0.57596815",
"0.5757105",
"0.5742337",
"0.57243687",
"0.5712514",
"0.57068694",
"0.5703828",
"0.5692578",
"0.5684955",
"0.5684955",
"0.5684955",
... | 0.57714236 | 9 |
Rotate the point cloud along up direction with certain angle. | def rotate_point_cloud_by_angle(batch_data, rotation_angle):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
#rotation_angle = np.random.uniform() * 2 * np.pi
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, 0, sinval],
[0, 1, 0],
[-sinval, 0, cosval]])
shape_pc = batch_data[k,:,0:3]
rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new ... | [
"0.6844331",
"0.6844331",
"0.6701853",
"0.64968896",
"0.6489468",
"0.63358444",
"0.63339704",
"0.6315883",
"0.6225028",
"0.6200144",
"0.6192065",
"0.6183062",
"0.6182096",
"0.6172054",
"0.6166697",
"0.6152675",
"0.6152675",
"0.6152675",
"0.6152675",
"0.6152249",
"0.6143772",
... | 0.57263416 | 58 |
Rotate the point cloud along up direction with certain angle. | def rotate_point_cloud_by_angle_with_normal(batch_data, rotation_angle):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
#rotation_angle = np.random.uniform() * 2 * np.pi
cosval = np.cos(rotation_angle)
sinval = np.sin(rotation_angle)
rotation_matrix = np.array([[cosval, 0, sinval],
[0, 1, 0],
[-sinval, 0, cosval]]) # rotate along y axis
shape_pc = batch_data[k,:,0:3]
shape_normal = batch_data[k,:,3:6]
rotated_data[k,:,0:3] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)
rotated_data[k,:,3:6] = np.dot(shape_normal.reshape((-1,3)), rotation_matrix)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotateZUp(self):\n MV = self.MV\n MV[:3, 1] = 0, 0, 1 # 2nd col is up vector, make it point along z axis\n # set bottom left and bottom right z values to zero:\n MV[2, 0] = 0\n MV[2, 2] = 0\n a = MV[0, 0] # grab top left value\n b = np.sqrt(1 - a**2) # calc new ... | [
"0.6844139",
"0.6844139",
"0.6701813",
"0.6496726",
"0.6489327",
"0.63356435",
"0.63336676",
"0.63157606",
"0.6224757",
"0.6200055",
"0.6191932",
"0.6182845",
"0.6181952",
"0.6171766",
"0.6166754",
"0.6152536",
"0.6152536",
"0.6152536",
"0.6152536",
"0.6152011",
"0.6143452",
... | 0.0 | -1 |
Randomly perturb the point clouds by small rotations | def rotate_perturbation_point_cloud(batch_data, angle_sigma=0.06, angle_clip=0.18):
rotated_data = np.zeros(batch_data.shape, dtype=np.float32)
for k in range(batch_data.shape[0]):
angles = np.clip(angle_sigma*np.random.randn(3), -angle_clip, angle_clip)
Rx = np.array([[1,0,0],
[0,np.cos(angles[0]),-np.sin(angles[0])],
[0,np.sin(angles[0]),np.cos(angles[0])]])
Ry = np.array([[np.cos(angles[1]),0,np.sin(angles[1])],
[0,1,0],
[-np.sin(angles[1]),0,np.cos(angles[1])]])
Rz = np.array([[np.cos(angles[2]),-np.sin(angles[2]),0],
[np.sin(angles[2]),np.cos(angles[2]),0],
[0,0,1]])
R = np.dot(Rz, np.dot(Ry,Rx))
shape_pc = batch_data[k, ...]
rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), R)
return rotated_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_epislon(self, cur_y, cur_z):\n old_loglik = self._loglik(cur_y, cur_z)\n old_epislon = self.epislon\n \n # modify the feature ownership matrix\n self.epislon = np.random.beta(1,1)\n new_loglik = self._loglik(cur_y, cur_z)\n move_prob = 1 / (1 + np.exp(old_lo... | [
"0.6232219",
"0.61596",
"0.6088852",
"0.6088638",
"0.60208404",
"0.59796554",
"0.5843116",
"0.5838049",
"0.5800207",
"0.57714236",
"0.5765245",
"0.57596815",
"0.5742337",
"0.57243687",
"0.5712514",
"0.57068694",
"0.5703828",
"0.5692578",
"0.5684955",
"0.5684955",
"0.5684955",... | 0.5757105 | 12 |
Randomly jitter points. jittering is per point. | def jitter_point_cloud(batch_data, sigma=0.01, clip=0.05):
B, N, C = batch_data.shape
assert(clip > 0)
jittered_data = np.clip(sigma * np.random.randn(B, N, C), -1*clip, clip)
jittered_data += batch_data
return jittered_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def jitter(interval):\n\treturn interval * (0.9 + 0.2 * random.random())",
"def rand_int_jitter():\n return random.randint(0, 10)",
"def jitter(x, y): \r\n dx = max(x) - min(x)\r\n dy = max(y) - min(y)\r\n assert(dx > 0)\r\n assert(dy > 0)\r\n d = math.sqrt(float(dx**2 + dy**2))\r\n print... | [
"0.73470956",
"0.72041214",
"0.71101594",
"0.70101404",
"0.67910165",
"0.6369184",
"0.6235321",
"0.6233606",
"0.6164337",
"0.6122401",
"0.6082923",
"0.6006233",
"0.5953184",
"0.595242",
"0.5943489",
"0.59328365",
"0.5924084",
"0.5902909",
"0.5856639",
"0.58350176",
"0.5834869... | 0.5786313 | 25 |
Randomly shift point cloud. Shift is per point cloud. | def shift_point_cloud(batch_data, shift_range=0.1):
B, N, C = batch_data.shape
shifts = np.random.uniform(-shift_range, shift_range, (B,3))
for batch_index in range(B):
batch_data[batch_index,:,:] += shifts[batch_index,:]
return batch_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift(self):\n \"\"\"\n shift cluster randomly within bounds of im\n \"\"\"\n r = self.std\n mid = self.mid_pixel #center pixel index of 384x384 image\n delta = self.im_size - self.mid_pixel - r - 10\n \n x = np.random.randint(low=-1*delta,high=delta,size... | [
"0.72441024",
"0.6811636",
"0.64971095",
"0.61066484",
"0.60589975",
"0.5939156",
"0.593459",
"0.5932551",
"0.5909121",
"0.57994634",
"0.57626474",
"0.5751564",
"0.57320094",
"0.57160926",
"0.5685124",
"0.56692094",
"0.56554824",
"0.564319",
"0.56338567",
"0.5614417",
"0.5607... | 0.7352118 | 0 |
Randomly scale the point cloud. Scale is per point cloud. | def random_scale_point_cloud(batch_data, scale_low=0.8, scale_high=1.25):
B, N, C = batch_data.shape
scales = np.random.uniform(scale_low, scale_high, B)
for batch_index in range(B):
batch_data[batch_index,:,:] *= scales[batch_index]
return batch_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale_point_cloud(batch_data, scale_ratio=0.8):\n B, N, C = batch_data.shape\n scale = np.random.uniform(scale_ratio,1/scale_ratio,(B,1,1))\n scaled_data = batch_data*scale\n return scaled_data",
"def ScalePoints(points, sigma = 0.02):\n assert(points.shape[1]==3)\n\n scale = np.random.unif... | [
"0.76311445",
"0.6895509",
"0.67543155",
"0.64973104",
"0.63981426",
"0.62324494",
"0.6162519",
"0.6148883",
"0.6085778",
"0.60736156",
"0.59713405",
"0.5954016",
"0.5944525",
"0.5929756",
"0.58707345",
"0.5869925",
"0.58671856",
"0.58244807",
"0.5817822",
"0.57851666",
"0.57... | 0.76930815 | 0 |
Shows message on application status bar | def show_status(self, status):
self.statusBar().showMessage(status, 2000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showStatus(self, message):\n self.status_bar.showMessage(message)",
"def statusbar_msg(self, msg):\n self.statusbar.clearMessage()\n self.statusbar.showMessage(msg)",
"def display_message(self, message):\n context_id = self.status_bar.get_context_id(\"\")\n self.status_ba... | [
"0.84011865",
"0.833993",
"0.8174036",
"0.77206886",
"0.76677835",
"0.75396955",
"0.75219834",
"0.75037515",
"0.7410699",
"0.73903996",
"0.7333679",
"0.72647804",
"0.7226942",
"0.70724267",
"0.7072069",
"0.7037532",
"0.70224166",
"0.69146335",
"0.6912863",
"0.6885066",
"0.681... | 0.81817955 | 2 |
Override the closeEvent method | def closeEvent(self, event):
if settings.IN_SYNC:
event.ignore()
QtGui.QMessageBox.information(self, "Abort", "You are in the middle of "
+ "a conflicted merge. Please resolve it first.")
else:
event.accept() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outCloseEvent(self):\r\n pass",
"def onClose(self, event):\n pass",
"def onClose(self, event):\n pass",
"def onClose(self, event):\n pass",
"def closeEvent(self, event):\n self.exit()\n event.accept()",
"def closeEvent(self, event):\n\n sys.exit()",
"def c... | [
"0.833176",
"0.82620287",
"0.82620287",
"0.82620287",
"0.80923194",
"0.8072515",
"0.80208814",
"0.80071384",
"0.8003962",
"0.7980135",
"0.7966298",
"0.78825104",
"0.78405327",
"0.784024",
"0.78278977",
"0.77431095",
"0.7715871",
"0.77045715",
"0.77030706",
"0.77030706",
"0.76... | 0.0 | -1 |
Gets valid user credentials from storage. If nothing has been stored, or if the stored credentials are invalid, the OAuth2 flow is completed to obtain the new credentials. | def get_credentials(data_dir_path, client_secret_file_path, scopes, application_name):
#home_dir = os.path.expanduser('~')
#credential_dir = os.path.join(home_dir, '.credentials')
credential_dir = os.path.join(data_dir_path, ".credentials")
if not os.path.exists(credential_dir):
os.makedirs(credential_dir)
credential_path = os.path.join(credential_dir,
'gmail-python-quickstart.json')
store = Storage(credential_path)
credentials = store.get()
if not credentials or credentials.invalid:
flow = client.flow_from_clientsecrets(client_secret_file_path, scopes)
flow.user_agent = application_name
try:
import argparse
flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()
except ImportError:
flags = None
if flags:
credentials = tools.run_flow(flow, store, flags)
else: # Needed only for compatibility with Python 2.6
credentials = tools.run(flow, store)
print('Storing credentials to ' + credential_path)
return credentials | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_user_credentials(self, storage):\n # Set up a Flow object to be used if we need to authenticate.\n flow = client.flow_from_clientsecrets(\n self.client_secrets,\n scope=self.api_scopes,\n message=tools.message_if_missing(self.client_secrets))\n\n # Re... | [
"0.7571535",
"0.7355913",
"0.71540344",
"0.7120326",
"0.70709026",
"0.7026004",
"0.6991126",
"0.69621813",
"0.6947445",
"0.69403243",
"0.69352114",
"0.69063586",
"0.68998873",
"0.6899442",
"0.6857314",
"0.6828924",
"0.679187",
"0.6784848",
"0.677493",
"0.677493",
"0.677493",
... | 0.6046647 | 96 |
return list of id of unread emails | def get_unread_email_ids(gmail_client):
response = gmail_client.users().messages().list(userId='me',q='is:unread').execute()
if 'messages' in response: # messages key only exists if there are unread messages
return [message['id'] for message in response['messages']]
else:
print("No unread messages...")
return [] # still return a list since that's what caller expects | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_unread_emails(self):\n try:\n query = 'is:unread from:scholaralerts-noreply@google.com'\n page_token = None\n p_emails = []\n while True:\n request = self.service.users().messages().list(userId='me',\n ... | [
"0.7194147",
"0.70722127",
"0.70129013",
"0.69660854",
"0.6963227",
"0.6954459",
"0.69394183",
"0.69240445",
"0.691629",
"0.68746626",
"0.68267304",
"0.67761564",
"0.67230296",
"0.6694524",
"0.6601468",
"0.6559419",
"0.6427694",
"0.6418745",
"0.6417917",
"0.63268363",
"0.6284... | 0.8231231 | 0 |
Use gmail api to find new emails Return email addresses of new emails and whether or not they have postcard | def get_unread_email_data(gmail_client):
unread_ids = get_unread_email_ids(gmail_client)
for message_id in unread_ids:
remove_unread_label = {'removeLabelIds': ['UNREAD']}
gmail_client.users().messages().modify(userId='me', id=message_id, body=remove_unread_label).execute()
message_data = gmail_client.users().messages().get(userId='me',id=message_id).execute()
message_payload = message_data['payload']
has_attachment = 0 < len([part for part in message_payload['parts'] if part['mimeType'] == 'image/jpeg'])
message_headers = message_payload['headers']
sender = [header['value'] for header in message_headers if header['name'] == 'Return-Path'][0]
yield sender, has_attachment | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_emails():\n\n # generate the gmail api service\n service = build_gmail_api_v1()\n\n # compute date for one year ago\n today = date.today()\n one_year_ago = today - timedelta(days=365.25)\n start = one_year_ago - timedelta(days=1)\n end = one_year_ago + timedelta(days=1)\n start_stri... | [
"0.6836338",
"0.68140227",
"0.6734633",
"0.6701311",
"0.6606506",
"0.6500365",
"0.649841",
"0.6341374",
"0.6327239",
"0.6249059",
"0.62106127",
"0.61267984",
"0.61160463",
"0.60011953",
"0.59610665",
"0.59563863",
"0.5922605",
"0.5915454",
"0.5888645",
"0.586136",
"0.58241683... | 0.5653958 | 27 |
Create a message for an email. | def create_message(sender, to, subject, message_text):
message = MIMEText(message_text)
message['to'] = to
message['from'] = sender
message['subject'] = subject
raw = base64.urlsafe_b64encode(message.as_bytes())
return {'raw':raw.decode()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )",
"def createMessage( self, *args, **kw ):\n if not kw.has_key('charset'):\n kw['charset'] = self.getOutputCharset()\n kw['to_mail'] = 1\n return MailServerBase.createMessage( self, *args, **kw )",
... | [
"0.8220897",
"0.783499",
"0.7542338",
"0.7535529",
"0.7519684",
"0.74869245",
"0.7417828",
"0.73909754",
"0.7373257",
"0.7355638",
"0.73106784",
"0.7269137",
"0.719846",
"0.7196095",
"0.7140178",
"0.7047853",
"0.7021525",
"0.70037013",
"0.70037013",
"0.68474555",
"0.68418366"... | 0.7297086 | 11 |
Send an email message. | def send_message(message, client):
try:
message = (client.users().messages().send(userId='me', body=message).execute())
print('Message Id: %s' % message['id'])
return message
except errors.HttpError as error:
print('An error occurred: %s' % error) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email(self, message):\n pass",
"def send_mail(email):\n return email.send()",
"def send_email(msg):\n\tprint(\"sendEmail: \" + msg)",
"def send_email(message):\n mail_server = smtplib.SMTP('localhost')\n mail_server.send_message(message)\n mail_server.quit()",
"def send_email(msg):\n ... | [
"0.8239757",
"0.80890095",
"0.79037267",
"0.78920776",
"0.7768939",
"0.7730623",
"0.7727504",
"0.76961035",
"0.76466435",
"0.7635667",
"0.7613354",
"0.7608988",
"0.7607686",
"0.7554999",
"0.7533295",
"0.7488125",
"0.74320126",
"0.74103194",
"0.7409468",
"0.7407818",
"0.740765... | 0.0 | -1 |
Makes a directory after checking whether it already exists. | def mkdir(directory, parents=True):
path_dir = Path(directory)
if not path_dir.exists():
path_dir.mkdir(parents=parents) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dir(self):\n if not os.path.exists(self.d):\n try:\n os.mkdir(self.d)\n except OSError, e:\n if e.errno != 17:\n raise\n pass",
"def new_dir(the_dir):\n try:\n os.makedirs(the_dir)\n except OSError ... | [
"0.83006763",
"0.81420314",
"0.80905235",
"0.7991284",
"0.7971449",
"0.7967864",
"0.79364747",
"0.79364747",
"0.7920723",
"0.7886012",
"0.78693926",
"0.78422606",
"0.7834246",
"0.7830855",
"0.78147686",
"0.7812152",
"0.7812152",
"0.7812152",
"0.7812152",
"0.78007835",
"0.7798... | 0.0 | -1 |
Removes an empty directory after checking whether it already exists. | def rmdir(directory, recursive=False):
path_dir = Path(directory)
if not path_dir.exists():
return
if recursive:
shutil.rmtree(path_dir)
else:
if len(list(path_dir.iterdir())) == 0:
path_dir.rmdir()
else:
raise ValueError(
"Cannot remove directory '{}' as it is not empty: consider removing it recursively".format(path_dir)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_empty_path(self, empty):\n while True:\n if not os.path.isdir(empty):\n\n # Directory does not exist\n return\n\n if os.listdir(empty):\n # Directory is not empty\n return\n\n try:\n os.rmd... | [
"0.8056177",
"0.78796035",
"0.7780004",
"0.7707977",
"0.7627978",
"0.7590993",
"0.75686836",
"0.75058484",
"0.7489895",
"0.7464971",
"0.74595416",
"0.7390957",
"0.7353166",
"0.7352782",
"0.7333176",
"0.7274257",
"0.725936",
"0.7209765",
"0.7153305",
"0.71452975",
"0.71025324"... | 0.0 | -1 |
Create a k cluster data set with required separation. For the purposes of validating a proof, generate each cluster center such that it is at least 4 delta away from any other cluster for some value of delta > 0. | def gen_k_centers(k, dim):
delta = abs(np.random.normal(0.0, 5.0))
eps = 0.001
centers = []
for i in range(k):
c = np.random.multivariate_normal(np.zeros(dim), np.identity(dim))
if len(centers):
c1 = centers[0]
x = np.random.multivariate_normal(c1, np.identity(c1.size)) - c1
direction = x / np.linalg.norm(x)
centers.append(c1 + 2.0 * i * delta * direction + eps)
else:
centers.append(c)
return centers, delta | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_clusters(self):\n ex = 0\n print 'Iter - Purity Gini Index'\n while ex < self.MAX_ITERATION:\n new_clusters = np.zeros(self.centroids.shape)\n distances = euclidean_distances(self.vectors, self.centroids).argmin(axis=1)\n for i in ran... | [
"0.7273148",
"0.7161901",
"0.71461064",
"0.70277727",
"0.6989481",
"0.6961698",
"0.69509083",
"0.6936706",
"0.69362247",
"0.68879706",
"0.68621993",
"0.67435825",
"0.6723467",
"0.67071426",
"0.67059225",
"0.66942155",
"0.66667116",
"0.6627539",
"0.6592454",
"0.6569137",
"0.65... | 0.73497814 | 0 |
Create a delta separated data set. Generate a set of centers for the clusters and from each center draw size number of points that constitute the points in that cluster. Then return a dataset of all points. | def create_dataset(dims, size, num_clusters=20):
clusters, delta = gen_k_centers(num_clusters, dims)
return _create_constrained_dataset(clusters, delta, size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_constrained_dataset(centers, delta, size):\n dataset = []\n count = 0\n for i, c in enumerate(centers):\n for j in range(size):\n x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c\n direction = x / np.linalg.norm(x)\n magnitude = np.rando... | [
"0.75692487",
"0.6472027",
"0.6142992",
"0.61193955",
"0.61097693",
"0.6057844",
"0.6014714",
"0.5996427",
"0.59905845",
"0.5968957",
"0.5963011",
"0.5947673",
"0.5943788",
"0.5909058",
"0.5908519",
"0.5902958",
"0.5898489",
"0.5893198",
"0.58916074",
"0.58719695",
"0.5860178... | 0.6139342 | 3 |
Create a deltaseparated dataset. For each of the centers draw size number of points. No two points may be farther than delta away form each other. Thus, to generate each point, choosea random direction and random distance from the center (of up to 0.5 delta). | def _create_constrained_dataset(centers, delta, size):
dataset = []
count = 0
for i, c in enumerate(centers):
for j in range(size):
x = np.random.multivariate_normal(c, np.identity(np.size(c))) - c
direction = x / np.linalg.norm(x)
magnitude = np.random.uniform(0.0, 0.5 * delta)
# magnitude = np.random.uniform(0.0, delta) # NOT DEL-SEPARATED
dataset.append((c + magnitude * direction, i, count))
count += 1
return dataset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_point_cloud(n:int, d:int = 2, seed=1234) -> np.ndarray:\n initial_seed = np.random.get_state()\n np.random.seed(seed)\n points = np.random.rand(n, d)\n np.random.set_state(initial_seed)\n return points",
"def generate(self, n, d, seperation=4.0, pos_fraction=0.5):\n self.n = n\... | [
"0.6200814",
"0.60125065",
"0.6008298",
"0.58964354",
"0.5652766",
"0.5627772",
"0.56074226",
"0.55708045",
"0.55676484",
"0.54426163",
"0.54371774",
"0.5432757",
"0.54286873",
"0.5412957",
"0.53979236",
"0.53931975",
"0.53886104",
"0.5388139",
"0.5384613",
"0.53822875",
"0.5... | 0.70498824 | 0 |
Create 4 cluster centers. Create gaussians centered at (1,1), (1,1), (1,1) and (1,1). Each has standard covariance. | def gen_4_normal():
return [mn(mean=np.array([1.0, 1.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([1.0, -1.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([-1.0, -1.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([-1.0, 1.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]]))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_centers(self):\n\t\tcenters = []\n\t\tsize = self.config.image_size\n\t\tfor i in range(self.config.num_obj):\n\t\t\tflag = True\n\t\t\twhile flag:\n\t\t\t\tc = np.random.randint(int(size * 0.05), int(size * 0.95), 2)\n\t\t\t\tflag = False\n\t\t\t\tfor center in centers:\n\t\t\t\t\tif (abs(center[0] -... | [
"0.6578101",
"0.6553022",
"0.6369997",
"0.63132054",
"0.62990874",
"0.62756854",
"0.62509024",
"0.6190687",
"0.6112884",
"0.6097691",
"0.60697997",
"0.60543525",
"0.5993539",
"0.598463",
"0.5970525",
"0.5952007",
"0.5925367",
"0.5922735",
"0.5904544",
"0.590372",
"0.590219",
... | 0.5482319 | 70 |
Create 4 cluster centers. Create gaussians centered at (10,10), (10,10), (10,10) and (10,10). Each has standard covariance. | def _4_normal_spread():
return [mn(mean=np.array([10.0, 10.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([10.0, -10.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([-10.0, -10.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]])),
mn(mean=np.array([-10.0, 10.0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]]))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_init(self, train_data):\n\n centroids=np.zeros((self.n_clusters_, train_data.shape[1]))\n for c in range(self.n_clusters_):\n for f in range(train_data.shape[1]):\n centroids[c,f]=random.uniform(min(train_data[:,f]), max(train_data[:,f]))\n\n return centroi... | [
"0.6637167",
"0.6619889",
"0.64092225",
"0.6370468",
"0.6316697",
"0.6288295",
"0.6286796",
"0.6268664",
"0.6214184",
"0.61212265",
"0.6098709",
"0.60670376",
"0.60576606",
"0.6025386",
"0.6019331",
"0.60053873",
"0.59957886",
"0.5989434",
"0.5931372",
"0.5907089",
"0.5906791... | 0.0 | -1 |
Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _5x5_grid_clusters():
return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(5)
for j in range(5)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25... | [
"0.76212066",
"0.7217054",
"0.71860254",
"0.69142705",
"0.68518704",
"0.68461156",
"0.66278195",
"0.66259587",
"0.6578559",
"0.63746804",
"0.63681006",
"0.63251126",
"0.6259267",
"0.62513924",
"0.6211149",
"0.62032765",
"0.61599225",
"0.6159027",
"0.6151934",
"0.6151934",
"0.... | 0.8075378 | 0 |
Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _5x5_grid_clusters_spread():
return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(5)
for j in range(5)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _10x10_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[... | [
"0.8075657",
"0.7216367",
"0.7186302",
"0.691356",
"0.68508494",
"0.6845249",
"0.66261995",
"0.6625447",
"0.6577691",
"0.6374363",
"0.63676125",
"0.6322932",
"0.625821",
"0.6250707",
"0.6211498",
"0.6203698",
"0.6160035",
"0.6157637",
"0.6151316",
"0.6151316",
"0.6094953",
... | 0.762155 | 1 |
Create a 5x5 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _5x5_grid_clusters_close():
return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(5)
for j in range(5)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.... | [
"0.80750877",
"0.7620803",
"0.72162825",
"0.69135714",
"0.6852057",
"0.6845415",
"0.66279685",
"0.6627276",
"0.65779185",
"0.6375827",
"0.6368961",
"0.6324704",
"0.62609804",
"0.62517524",
"0.6210675",
"0.6203783",
"0.6160406",
"0.61593336",
"0.6152343",
"0.6152343",
"0.60966... | 0.7185599 | 3 |
Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _2x3_grid_clusters_close():
return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(2)
for j in range(3)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.... | [
"0.7743275",
"0.7348963",
"0.7345636",
"0.72138846",
"0.693622",
"0.6857599",
"0.678586",
"0.6746427",
"0.6744042",
"0.6541813",
"0.6501836",
"0.65014625",
"0.6451203",
"0.631673",
"0.63058984",
"0.6281105",
"0.6236732",
"0.6231005",
"0.62132615",
"0.62098527",
"0.6208093",
... | 0.677395 | 7 |
Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _2x3_grid_clusters_spread():
return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(2)
for j in range(3)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.... | [
"0.7741456",
"0.7347127",
"0.7343865",
"0.69358754",
"0.68556786",
"0.6784003",
"0.67725694",
"0.67446214",
"0.6744467",
"0.6542266",
"0.65019643",
"0.6500571",
"0.6449538",
"0.6316034",
"0.63062775",
"0.6281654",
"0.62352514",
"0.62311894",
"0.6211723",
"0.6209921",
"0.62071... | 0.72126484 | 3 |
Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _10x10_grid_clusters_close():
return [mn(mean=np.array([i * 5, j * 5]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(10)
for j in range(10)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.... | [
"0.7742221",
"0.734794",
"0.7344126",
"0.7212588",
"0.6936357",
"0.678427",
"0.67730224",
"0.6745758",
"0.67450356",
"0.65422076",
"0.65023965",
"0.6501117",
"0.6449754",
"0.63159335",
"0.6306894",
"0.628159",
"0.6236001",
"0.6232418",
"0.6210907",
"0.62107736",
"0.62073714",... | 0.6856434 | 5 |
Create a 3x3 grid of cluster centers. Create 25 cluster centers on the grid I^{[0, 4] x [0,4]}. Each center is a gaussian with standard covariance | def _10x10_grid_clusters_spread():
return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.0, 0.0],
[0.0, 1.0]]))
for i in range(10)
for j in range(10)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _5x5_grid_clusters():\n return [mn(mean=np.array([i, j]), cov=np.array([[1.0, 0.0],\n [0.0, 1.0]]))\n for i in range(5)\n for j in range(5)]",
"def _5x5_grid_clusters_spread():\n return [mn(mean=np.array([i * 25, j * 25]), cov=np.array([[1.... | [
"0.7741881",
"0.73474836",
"0.7212278",
"0.69355553",
"0.68558514",
"0.67842954",
"0.67727154",
"0.6745349",
"0.67441016",
"0.6541365",
"0.65011424",
"0.6499605",
"0.6450051",
"0.63159925",
"0.6306321",
"0.6281557",
"0.6235609",
"0.6231545",
"0.62127733",
"0.6210027",
"0.6207... | 0.7343511 | 2 |
Create random cluster centers. Create n cluster centers randomly. Each cluster center is a draw from a gaussian distribution centered at (0,0) with standard covariance. | def _random_standard_centers(n=100):
generator = mn(mean=np.array([0, 0]),
cov=np.array([[1.0, 0.0], [0.0, 1.0]]))
return [mn(mean=pt, cov=np.array([[1.0, 0.0], [0.0, 1.0]]))
for pt in generator.rvs(size=n)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_sample_clusters(n_clusters, n_points, n_features=2, std=2, seed=1, limits=(-10, 10)):\n points_per_cluster = n_points // n_clusters\n np.random.seed(seed=seed)\n centroids = []\n for _ in range(n_features):\n centroids.append(np.random.randint(limits[0], limits[1], size=n_clusters))\n\n... | [
"0.76822317",
"0.76259226",
"0.73836875",
"0.7335838",
"0.7241687",
"0.7094557",
"0.7092686",
"0.7072594",
"0.7042424",
"0.6994134",
"0.6977371",
"0.69499964",
"0.6929814",
"0.6919069",
"0.6892269",
"0.6817309",
"0.6758312",
"0.6726237",
"0.6718225",
"0.66974187",
"0.6696951"... | 0.7926905 | 0 |
Method that returns the JSON string representation of list_dictionaries | def to_json_string(list_dictionaries):
if list_dictionaries is None:
return "[]"
else:
string = json.dumps(list_dictionaries)
return string | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n list_dictionaries = []\n return json.dumps(list_dictionaries)",
"def to_json_string(list_dictionaries):\n if list_dictionaries is None:\n list_dictionaries = []\n return json.dumps(list_dict... | [
"0.841099",
"0.841099",
"0.8314405",
"0.8295821",
"0.8295821",
"0.8267931",
"0.8262547",
"0.8249925",
"0.82311714",
"0.8218337",
"0.8209053",
"0.81681156",
"0.8161104",
"0.81400317",
"0.8131461",
"0.81231254",
"0.8110287",
"0.80916226",
"0.74270463",
"0.6780553",
"0.67750645"... | 0.81934065 | 11 |
Method that writes the JSON string representation of list_objs to a file | def save_to_file(cls, list_objs):
filename = cls.__name__ + ".json"
result = []
if list_objs:
for objs in list_objs:
dictionary = objs.to_dictionary()
result.append(dictionary)
with open(filename, "w", encoding="utf-8") as file:
file.write(cls.to_json_string(result)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_to_file(cls, list_objs):\n filename = cls.__name__ + \".json\"\n with open(filename, \"w\") as f:\n if list_objs is None:\n f.write(\"[]\")\n else:\n d = [x.to_dictionary() for x in list_objs]\n f.write(Base.to_json_string(d)... | [
"0.86339736",
"0.8606109",
"0.8603492",
"0.85995936",
"0.8557784",
"0.8546807",
"0.85401046",
"0.8516957",
"0.8511827",
"0.84710205",
"0.84403396",
"0.8420791",
"0.8380287",
"0.8351859",
"0.83487356",
"0.8338624",
"0.832877",
"0.82504755",
"0.824626",
"0.8242384",
"0.8223594"... | 0.83550686 | 13 |
Method that returns the list of the JSON string representation json_string | def from_json_string(json_string):
if json_string is None or len(json_string) == 0:
return []
return json.loads(json_string) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_json_string(json_string):\n lis = []\n # not sure if empty means empty string or len(jstr) < 1\n if json_string is None or json_string == \"\":\n return lis\n return json.loads(json_string)",
"def from_json_string(json_string):\n empty_list = []\n if ... | [
"0.7202782",
"0.71640325",
"0.71429116",
"0.7090925",
"0.70497406",
"0.70338446",
"0.6975703",
"0.68670994",
"0.6847883",
"0.6829183",
"0.6806034",
"0.6722226",
"0.66883564",
"0.6621443",
"0.66010094",
"0.66010094",
"0.6556371",
"0.6529802",
"0.648166",
"0.64465785",
"0.63312... | 0.64909357 | 19 |
Method that returns an instance with all attributes already set | def create(cls, **dictionary):
if cls.__name__ == "Rectangle":
dummy = cls(1, 1)
elif cls.__name__ == "Square":
dummy = cls(1)
dummy.update(**dictionary)
return dummy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n def init(self, **kwargs):\n \"\"\"Initialization.\"\"\"\n for k, v in kwargs.items():\n setattr(self, k, v)\n\n return type(type(self).__name__, (type(self),), {\"__init__\": init})(**self.__dict__)",
"def make(cls, **kwargs):\r\n return... | [
"0.6719594",
"0.6588282",
"0.6492425",
"0.643093",
"0.63870096",
"0.638417",
"0.638417",
"0.6381096",
"0.6337553",
"0.63111466",
"0.63078123",
"0.6277938",
"0.62500143",
"0.6229394",
"0.6193025",
"0.6179197",
"0.61522555",
"0.6148272",
"0.61313915",
"0.6122863",
"0.60904044",... | 0.0 | -1 |
Method that returns a list of instances | def load_from_file(cls):
filename = cls.__name__ + ".json"
result = []
try:
with open(filename, encoding="utf-8") as file:
obj_list = cls.from_json_string(file.read())
for dictionary in obj_list:
result.append(cls.create(**dictionary))
return result
except:
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_instances(cls):\n raise NotImplementedError",
"def list_instances(self):\n # list instances\n self._list_instances()",
"async def get_instances(self, **kwargs) -> List[ApiResource]:\n raw_resources = await self.get_resources(**kwargs)\n _instances = [\n sel... | [
"0.8240453",
"0.77040386",
"0.7198313",
"0.7156317",
"0.7027863",
"0.70239186",
"0.69569033",
"0.69567513",
"0.6942843",
"0.6935414",
"0.6921797",
"0.6883705",
"0.6883301",
"0.6853721",
"0.6853102",
"0.6853102",
"0.68430334",
"0.68341786",
"0.68341786",
"0.68209326",
"0.68209... | 0.0 | -1 |
Method to serialize in csv | def save_to_file_csv(cls, list_objs):
list_rectangle = ["id", "width", "height", "x", "y"]
list_square = ["id", "size", "x", "y"]
filename = cls.__name__ + ".csv"
result = []
if list_objs:
for objs in list_objs:
# First recollect the info of the object with a dict
dictionary = objs.to_dictionary()
middle_result = []
# Second obtein the values in a ordered class list
if cls.__name__ == "Rectangle":
for item in list_rectangle:
middle_result.append(dictionary[item])
if cls.__name__ == "Square":
for item in list_square:
middle_result.append(dictionary[item])
# append the list to result list
result.append(middle_result)
with open(filename, "w", encoding="utf-8") as file:
writer = csv.writer(file)
writer.writerows(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_csv_string(self, **kwargs):\n ...",
"def to_csv(self, csvwriter):\n csvwriter.writerow(self.to_csv_row())",
"def toCsv(self, csv_path):\n ser = pd.Series(self)\n ser.to_csv(csv_path)",
"def ToCsv(self):\n\n def csv_helper(the_dict, the_field):\n if the_field not ... | [
"0.73075175",
"0.7227191",
"0.7032894",
"0.70270133",
"0.6928391",
"0.6888921",
"0.6879478",
"0.6835335",
"0.67983305",
"0.665103",
"0.6593733",
"0.6589045",
"0.6541852",
"0.6517649",
"0.6497261",
"0.6496066",
"0.6471588",
"0.64418876",
"0.6415566",
"0.6408056",
"0.6371749",
... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.